Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

597 files changed, 661999 insertions, 0 deletions

diff --git a/js/src/jit-test/tests/wasm/README-codegen.md b/js/src/jit-test/tests/wasm/README-codegen.md
new file mode 100644
index 0000000000..007063c20a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/README-codegen.md
@@ -0,0 +1,36 @@
+About whitebox code generation tests (*-codegen.js) in this dir and
+the simd subdir.
+
+Whitebox codegen tests test a couple of things:
+
+- that the best instructions are selected under ideal conditions:
+  showing that the instruction selector at least knows about these
+  instructions.
+
+- that extraneous moves are not inserted by the register allocator or
+  code generator under ideal conditions: when it is in principle
+  possible for the code generator and register allocator to use inputs
+  where they are and generate outputs directly in the target
+  registers.
+
+These tests are both limited in scope and brittle in the face of
+changes to the register allocator and instruction selector, but how
+else would we test that code generation and register allocation work
+when presented with the easiest case?  And if they don't work then,
+when will they work?
+
+For a reliable test, the inputs must be known to be in the fixed
+parameter registers and the result must be known to be desired in the
+fixed function result register.
+
+Sometimes, to test optimal codegen, we need the inputs to be in
+reversed or permuted locations so as to avoid generating moves that
+are inserted by the regalloc to adapt to the function signature, or
+there need to be some dummy parameter registers that are not used.
+
+In the test cases, the expected output is expressed as a multi-line
+regular expression.  The first line of each expected output is the
+tail end of the prologue; subsequent lines comprise the operation;
+finally there is the beginning of the epilogue.  Sometimes there is
+only the end of the prologue and the beginning of the operation, as
+the operation is long and we don't care about its tail.
diff --git a/js/src/jit-test/tests/wasm/arm-hwcap-madness.js b/js/src/jit-test/tests/wasm/arm-hwcap-madness.js
new file mode 100644
index 0000000000..cb3b281619
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/arm-hwcap-madness.js
@@ -0,0 +1,31 @@
+// |jit-test| skip-if: !getBuildConfiguration().arm; test-also=--arm-hwcap=armv7,vfp
+
+// The command line options disable the idiv instruction and thus make the
+// baseline compiler unavailable, so we must be prepared for a run-time error
+// below in the baseline-only configuration.
+
+// The flags above should be sufficient for there to be a WebAssembly object.
+assertEq(typeof WebAssembly, "object");
+
+try {
+    var i = new WebAssembly.Instance(
+        new WebAssembly.Module(
+            wasmTextToBinary('(module (func (export "") (result i32) (i32.const 42)))')));
+    assertEq(i.exports[""](), 42);
+} catch (e) {
+    if (String(e).match(/no WebAssembly compiler available/)) {
+        switch (wasmCompileMode()) {
+        case "none":
+            // This is fine: the limited feature set combined with command line
+            // compiler selection caused all compilers to be disabled.
+            break;
+        default:
+            // This is not fine: if there's a compiler available then we should
+            // not get an error.
+            throw e;
+        }
+    } else {
+        // Some other error, propagate it.
+        throw e;
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/async-instantiate.js b/js/src/jit-test/tests/wasm/async-instantiate.js
new file mode 100644
index 0000000000..f10d0a47c1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/async-instantiate.js
@@ -0,0 +1,47 @@
+const { Module, Instance, Global, instantiate, instantiateStreaming } = WebAssembly;
+
+const g = new Global({value: "i32", mutable:true}, 0);
+
+const code = wasmTextToBinary(`(module
+    (global $g (import "" "g") (mut i32))
+    (func $start (set_global $g (i32.add (get_global $g) (i32.const 1))))
+    (start $start)
+)`);
+const module = new Module(code);
+
+const importObj = { '': { get g() { g.value++; return g } } };
+
+g.value = 0;
+new Instance(module, importObj);
+assertEq(g.value, 2);
+
+g.value = 0;
+instantiate(module, importObj).then(i => {
+  assertEq(i instanceof Instance, true);
+  assertEq(g.value, 2);
+  g.value++;
+});
+assertEq(g.value, 1);
+drainJobQueue();
+assertEq(g.value, 3);
+
+g.value = 0;
+instantiate(code, importObj).then(({module,instance}) => {
+    assertEq(module instanceof Module, true);
+    assertEq(instance instanceof Instance, true);
+    assertEq(g.value, 2); g.value++; }
+);
+drainJobQueue();
+assertEq(g.value, 3);
+
+if (wasmStreamingEnabled()) {
+  g.value = 0;
+  instantiateStreaming(code, importObj).then(({module,instance}) => {
+      assertEq(module instanceof Module, true);
+      assertEq(instance instanceof Instance, true);
+      assertEq(g.value, 2);
+      g.value++;
+  });
+  drainJobQueue();
+  assertEq(g.value, 3);
+}
diff --git a/js/src/jit-test/tests/wasm/atomic.js b/js/src/jit-test/tests/wasm/atomic.js
new file mode 100644
index 0000000000..f2508783ad
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/atomic.js
@@ -0,0 +1,562 @@
+// |jit-test| skip-if: !wasmThreadsEnabled()
+
+const oob = /index out of bounds/;
+const unaligned = /unaligned memory access/;
+const RuntimeError = WebAssembly.RuntimeError;
+
+function valText(text) {
+    return WebAssembly.validate(wasmTextToBinary(text));
+}
+
+function assertNum(a, b) {
+    if (typeof a == "number" && typeof b == "number")
+	assertEq(a, b);
+    else if (typeof a == "number") {
+	assertEq(a, b.low);
+	assertEq(0, b.high);
+    } else if (typeof b == "number") {
+	assertEq(a.low, b);
+	assertEq(a.high, 0);
+    } else {
+	assertEq(a.high, b.high);
+	assertEq(a.low, b.low);
+    }
+}
+
+// Check that the output of wasmTextToBinary verifies correctly.
+
+for ( let shared of ['shared', ''] ) {
+    for (let [type,width,view] of [['i32','8', '_u'],['i32','16','_u'],['i32','',''],['i64','8','_u'],['i64','16','_u'],['i64','32','_u'],['i64','','']]) {
+        {
+	    let text = (shared) => `(module (memory 1 1 ${shared})
+				 (func (result ${type}) (${type}.atomic.load${width}${view} (i32.const 0)))
+				 (export "" (func 0)))`;
+	    assertEq(valText(text(shared)), true);
+        }
+
+        {
+	    let text = (shared) => `(module (memory 1 1 ${shared})
+				 (func (${type}.atomic.store${width} (i32.const 0) (${type}.const 1)))
+				 (export "" (func 0)))`;
+	    assertEq(valText(text(shared)), true);
+        }
+
+        {
+	    let text = (shared) => `(module (memory 1 1 ${shared})
+				 (func (result ${type})
+				  (${type}.atomic.rmw${width}.cmpxchg${view} (i32.const 0) (${type}.const 1) (${type}.const 2)))
+				 (export "" (func 0)))`;
+	    assertEq(valText(text(shared)), true);
+        }
+
+        for (let op of ['add','and','or','sub','xor','xchg']) {
+	    // Operate with appropriately-typed value 1 on address 0
+	    let text = (shared) => `(module (memory 1 1 ${shared})
+				 (func (result ${type}) (${type}.atomic.rmw${width}.${op}${view} (i32.const 0) (${type}.const 1)))
+				 (export "" (func 0)))`;
+
+	    assertEq(valText(text(shared)), true);
+        }
+    }
+
+    for (let type of ['i32', 'i64']) {
+        let text = (shared) => `(module (memory 1 1 ${shared})
+			     (func (result i32) (${type}.atomic.wait (i32.const 0) (${type}.const 1) (i64.const -1)))
+			     (export "" (func 0)))`;
+        assertEq(valText(text(shared)), true);
+    }
+
+    let text = (shared) => `(module (memory 1 1 ${shared})
+	     (func (result i32) (atomic.notify (i32.const 0) (i32.const 1)))
+	     (export "" (func 0)))`;
+    assertEq(valText(text(shared)), true);
+
+    // Required explicit alignment for WAIT is the size of the datum
+
+    for (let [type,align,good] of [['i32',1,false],['i32',2,false],['i32',4,true],['i32',8,false],
+			           ['i64',1,false],['i64',2,false],['i64',4,false],['i64',8,true]])
+    {
+        let text = `(module (memory 1 1 shared)
+		 (func (result i32) (${type}.atomic.wait align=${align} (i32.const 0) (${type}.const 1) (i64.const -1)))
+		 (export "" (func 0)))`;
+        assertEq(valText(text), good);
+    }
+
+    // Required explicit alignment for NOTIFY is 4
+
+    for (let align of [1, 2, 4, 8]) {
+        let text = `(module (memory 1 1 shared)
+		 (func (result i32) (atomic.notify align=${align} (i32.const 0) (i32.const 1)))
+		 (export "" (func 0)))`;
+        assertEq(valText(text), align == 4);
+    }
+}
+
+// Test that atomic operations work.
+
+function I64(hi, lo) {
+    this.high = hi;
+    this.low = lo;
+}
+I64.prototype.toString = function () {
+    return "(" + this.high.toString(16) + " " + this.low.toString(16) + ")";
+}
+
+function Uint64Array(arg) {
+    let buffer = arg;
+    if (typeof arg == "number")
+	buffer = new ArrayBuffer(arg*8);
+    this.buf = buffer;
+    this.elem = new Uint32Array(buffer);
+}
+
+Uint64Array.BYTES_PER_ELEMENT = 8;
+
+Uint8Array.prototype.read = function (n) { return this[n] }
+Uint16Array.prototype.read = function (n) { return this[n] }
+Uint32Array.prototype.read = function (n) { return this[n] }
+Uint64Array.prototype.read = function (n) {
+    return new I64(this.elem[n*2+1], this.elem[n*2]);
+}
+
+Uint8Array.prototype.write = function (n,v) { this[n] = v }
+Uint16Array.prototype.write = function (n,v) { this[n] = v }
+Uint32Array.prototype.write = function (n,v) { this[n] = v}
+Uint64Array.prototype.write = function (n,v) {
+    if (typeof v == "number") {
+	// Note, this chops v if v is too large
+	this.elem[n*2] = v;
+	this.elem[n*2+1] = 0;
+    } else {
+	this.elem[n*2] = v.low;
+	this.elem[n*2+1] = v.high;
+    }
+}
+
+// Widen a one-byte value to a k-byte value where k is TA's width.
+// Complementation leads to better error checking, probably.
+
+function widen(TA, value, complement = true) {
+    let n = value;
+    let s = "";
+    for ( let i=0; i < Math.min(TA.BYTES_PER_ELEMENT, 4); i++ ) {
+	let v = (256 + n).toString(16);
+	s = s + v.substring(v.length-2);
+	if (complement)
+	    n = ~n;
+    }
+    if (TA.BYTES_PER_ELEMENT == 8)
+	s = s + s;
+    s = "0x" + s;
+
+    n = value;
+    let num = 0;
+    for ( let i=0; i < Math.min(TA.BYTES_PER_ELEMENT, 4); i++ ) {
+	num = (num << 8) | (n & 255);
+	if (complement)
+	    n = ~n;
+    }
+    num = num >>> 0;
+
+    if (TA.BYTES_PER_ELEMENT == 8) {
+	return [s, new I64(num, num)];
+    } else {
+	return [s, num];
+    }
+}
+
+// Atomic RMW ops are sometimes used for effect, sometimes for their value, and
+// in SpiderMonkey code generation differs for the two cases, so we need to test
+// both.  Also, there may be different paths for constant addresses/operands and
+// variable ditto, so test as many combinations as possible.
+
+for ( let shared of ['shared',''] ) {
+    let RMWOperation = {
+        loadStoreModule(type, width, view, address, operand) {
+	    let bin = wasmTextToBinary(
+	        `(module
+	      (memory (import "" "memory") 1 1 ${shared})
+	      (func (export "st") (param i32)
+	       (${type}.atomic.store${width} ${address} ${operand}))
+	      (func $ld (param i32) (result ${type})
+	       (${type}.atomic.load${width}${view} ${address}))
+	      (func (export "ld") (param i32) (result i32)
+	       (${type}.eq (call $ld (local.get 0)) ${operand})))`);
+	    let mod = new WebAssembly.Module(bin);
+	    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared});
+	    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+	    return [mem, ins.exports.ld, ins.exports.st];
+        },
+
+        opModuleEffect(type, width, view, address, op, operand, ignored) {
+	    let bin = wasmTextToBinary(
+	        `(module
+	      (memory (import "" "memory") 1 1 ${shared})
+	      (func (export "f") (param i32) (result i32)
+	       (drop (${type}.atomic.rmw${width}.${op}${view} ${address} ${operand}))
+	       (i32.const 1)))`);
+	    let mod = new WebAssembly.Module(bin);
+	    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared});
+	    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+	    return [mem, ins.exports.f];
+        },
+
+        opModuleReturned(type, width, view, address, op, operand, expected) {
+	    let bin = wasmTextToBinary(
+	        `(module
+	      (memory (import "" "memory") 1 1 ${shared})
+	      (func $_f (param i32) (result ${type})
+	       (${type}.atomic.rmw${width}.${op}${view} ${address} ${operand}))
+	      (func (export "f") (param i32) (result i32)
+	       (${type}.eq (call $_f (local.get 0)) (${type}.const ${expected}))))`);
+	    let mod = new WebAssembly.Module(bin);
+	    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared});
+	    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+	    return [mem, ins.exports.f];
+        },
+
+        cmpxchgModuleEffect(type, width, view, address, operand1, operand2, ignored) {
+	    let bin = wasmTextToBinary(
+	        `(module
+	      (memory (import "" "memory") 1 1 ${shared})
+	      (func (export "f") (param i32)
+	       (drop (${type}.atomic.rmw${width}.cmpxchg${view} ${address} ${operand1} ${operand2}))))`);
+	    let mod = new WebAssembly.Module(bin);
+	    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared});
+	    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+	    return [mem, ins.exports.f];
+        },
+
+        cmpxchgModuleReturned(type, width, view, address, operand1, operand2, expected) {
+	    let bin = wasmTextToBinary(
+	        `(module
+	      (memory (import "" "memory") 1 1 ${shared})
+	      (func $_f (param i32) (result ${type})
+	       (${type}.atomic.rmw${width}.cmpxchg${view} ${address} ${operand1} ${operand2}))
+	      (func (export "f") (param i32) (result i32)
+	       (${type}.eq (call $_f (local.get 0)) (${type}.const ${expected}))))`);
+	    let mod = new WebAssembly.Module(bin);
+	    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared});
+	    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+	    return [mem, ins.exports.f];
+        },
+
+        assertZero(array, LOC) {
+	    for ( let i=0 ; i < 100 ; i++ ) {
+	        if (i != LOC)
+		    assertNum(array.read(i), 0);
+	    }
+        },
+
+        run() {
+	    const LOC = 13;		// The cell we operate on
+	    const OPD1 = 37;	// Sometimes we'll put an operand here
+	    const OPD2 = 42;	// Sometimes we'll put another operand here
+
+	    for ( let [type, variations] of
+	          [["i32", [[Uint8Array,"8", "_u"], [Uint16Array,"16", "_u"], [Uint32Array,"",""]]],
+		   ["i64", [[Uint8Array,"8","_u"], [Uint16Array,"16","_u"], [Uint32Array,"32","_u"], [Uint64Array,"",""]]]] )
+	    {
+	        for ( let [TA, width, view] of variations )
+	        {
+		    for ( let addr of [`(i32.const ${LOC * TA.BYTES_PER_ELEMENT})`,
+				       `(local.get 0)`] )
+		    {
+		        for ( let [initial, operand] of [[0x12, 0x37]] )
+		        {
+			    let [opd_str, opd_num] = widen(TA, operand);
+			    for ( let rhs of [`(${type}.const ${opd_str})`,
+					      `(${type}.load${width}${view} (i32.const ${OPD1 * TA.BYTES_PER_ELEMENT}))`] )
+			    {
+			        let [mem, ld, st] = this.loadStoreModule(type, width, view, addr, rhs);
+			        let array = new TA(mem.buffer);
+			        array.write(OPD1, opd_num);
+			        array.write(LOC, initial);
+			        st(LOC * TA.BYTES_PER_ELEMENT);
+			        let res = ld(LOC * TA.BYTES_PER_ELEMENT);
+			        assertEq(res, 1);
+			        assertNum(array.read(LOC), opd_num);
+			        array.write(OPD1, 0);
+			        this.assertZero(array, LOC);
+			    }
+		        }
+
+		        for ( let [op, initial, operand, expected] of [["add", 37, 5, 42],
+								       ["sub", 42, 5, 37],
+								       ["and", 0x45, 0x13, 0x01],
+								       ["or",  0x45, 0x13, 0x57],
+								       ["xor", 0x45, 0x13, 0x56],
+								       ["xchg", 0x45, 0x13, 0x13]] )
+		        {
+			    let complement = op == "xchg";
+			    let [ini_str, ini_num] = widen(TA, initial, complement);
+			    let [opd_str, opd_num] = widen(TA, operand, complement);
+			    let [exp_str, exp_num] = widen(TA, expected, complement);
+			    for ( let rhs of [`(${type}.const ${opd_str})`,
+					      `(${type}.load${width}${view} (i32.const ${OPD1 * TA.BYTES_PER_ELEMENT}))`] )
+			    {
+			        for ( let [generateIt, checkIt] of [["opModuleEffect", false], ["opModuleReturned", true]] )
+			        {
+				    let [mem, f] = this[generateIt](type, width, view, addr, op, rhs, ini_str);
+				    let array = new TA(mem.buffer);
+				    array.write(OPD1, opd_num);
+				    array.write(LOC, ini_num);
+				    let res = f(LOC * TA.BYTES_PER_ELEMENT);
+				    if (checkIt)
+				        assertEq(res, 1);
+				    assertNum(array.read(LOC), exp_num);
+				    array.write(OPD1, 0);
+				    this.assertZero(array, LOC);
+			        }
+			    }
+		        }
+
+		        for ( let [initial, operand1, operand2, expected] of [[33, 33, 44, 44], [33, 44, 55, 33]] )
+		        {
+			    let [ini_str, ini_num] = widen(TA, initial);
+			    let [opd1_str, opd1_num] = widen(TA, operand1);
+			    let [opd2_str, opd2_num] = widen(TA, operand2);
+			    let [exp_str, exp_num] = widen(TA, expected);
+			    for ( let op1 of [`(${type}.const ${opd1_str})`,
+					      `(${type}.load${width}${view} (i32.const ${OPD1 * TA.BYTES_PER_ELEMENT}))`] )
+			    {
+			        for ( let op2 of [`(${type}.const ${opd2_str})`,
+					          `(${type}.load${width}${view} (i32.const ${OPD2 * TA.BYTES_PER_ELEMENT}))`] )
+			        {
+				    for ( let [generateIt, checkIt] of [["cmpxchgModuleEffect", false], ["cmpxchgModuleReturned", true]] )
+				    {
+				        let [mem, f] = this[generateIt](type, width, view, addr, op1, op2, ini_str);
+				        let array = new TA(mem.buffer);
+				        array.write(OPD1, opd1_num);
+				        array.write(OPD2, opd2_num);
+				        array.write(LOC, ini_num);
+				        let res = f(LOC * TA.BYTES_PER_ELEMENT);
+				        if (checkIt)
+					    assertEq(res, 1);
+				        assertNum(array.read(13), exp_num);
+				        array.write(OPD1, 0);
+				        array.write(OPD2, 0);
+				        this.assertZero(array, LOC);
+				    }
+			        }
+			    }
+		        }
+		    }
+	        }
+	    }
+        }
+    };
+
+    RMWOperation.run();
+}
+
+// Test bounds and alignment checking on atomic ops
+
+for ( let shared of ['shared',''] ) {
+    var BoundsAndAlignment = {
+        loadModule(type, view, width, offset) {
+	    return wasmEvalText(
+	        `(module
+	      (memory 1 1 ${shared})
+	      (func $0 (param i32) (result ${type})
+	       (${type}.atomic.load${width}${view} offset=${offset} (local.get 0)))
+	      (func (export "f") (param i32)
+	       (drop (call $0 (local.get 0)))))
+	    `).exports.f;
+        },
+
+        loadModuleIgnored(type, view, width, offset) {
+	    return wasmEvalText(
+	        `(module
+	      (memory 1 1 ${shared})
+	      (func (export "f") (param i32)
+	       (drop (${type}.atomic.load${width}${view} offset=${offset} (local.get 0)))))
+	    `).exports.f;
+        },
+
+        storeModule(type, view, width, offset) {
+	    return wasmEvalText(
+	        `(module
+	      (memory 1 1 ${shared})
+	      (func (export "f") (param i32)
+	       (${type}.atomic.store${width} offset=${offset} (local.get 0) (${type}.const 37))))
+	    `).exports.f;
+        },
+
+        opModule(type, view, width, offset, op) {
+	    return wasmEvalText(
+	        `(module
+	      (memory 1 1 ${shared})
+	      (func $0 (param i32) (result ${type})
+	       (${type}.atomic.rmw${width}.${op}${view} offset=${offset} (local.get 0) (${type}.const 37)))
+	      (func (export "f") (param i32)
+	       (drop (call $0 (local.get 0)))))
+	    `).exports.f;
+        },
+
+        opModuleForEffect(type, view, width, offset, op) {
+	    return wasmEvalText(
+	        `(module
+	      (memory 1 1 ${shared})
+	      (func (export "f") (param i32)
+	       (drop (${type}.atomic.rmw${width}.${op}${view} offset=${offset} (local.get 0) (${type}.const 37)))))
+	    `).exports.f;
+        },
+
+        cmpxchgModule(type, view, width, offset) {
+	    return wasmEvalText(
+	        `(module
+	      (memory 1 1 ${shared})
+	      (func $0 (param i32) (result ${type})
+	       (${type}.atomic.rmw${width}.cmpxchg${view} offset=${offset} (local.get 0) (${type}.const 37) (${type}.const 42)))
+	      (func (export "f") (param i32)
+	       (drop (call $0 (local.get 0)))))
+	    `).exports.f;
+        },
+
+        run() {
+	    for ( let [type, variations] of [["i32", [["8","_u", 1], ["16","_u", 2], ["","", 4]]],
+					     ["i64", [["8","_u",1], ["16","_u",2], ["32","_u",4], ["","",8]]]] )
+	    {
+	        for ( let [width,view,size] of variations )
+	        {
+		    // Aligned but out-of-bounds
+		    let addrs = [[65536, 0, oob], [65536*2, 0, oob], [65532, 4, oob],
+			         [65533, 3, oob], [65534, 2, oob], [65535, 1, oob]];
+                    if (type == "i64")
+                        addrs.push([65536-8, 8, oob]);
+
+		    // In-bounds but unaligned
+		    for ( let i=1 ; i < size ; i++ )
+		        addrs.push([65520, i, unaligned]);
+
+		    // Both out-of-bounds and unaligned.  The spec leaves it unspecified
+		    // whether we see the OOB message or the unaligned message (they are
+		    // both "traps").  In Firefox, the unaligned check comes first.
+		    for ( let i=1 ; i < size ; i++ )
+		        addrs.push([65536, i, unaligned]);
+
+		    // GC to prevent TSan builds from running out of memory.
+		    gc();
+
+		    for ( let [ base, offset, re ] of addrs )
+		    {
+		        assertErrorMessage(() => this.loadModule(type, view, width, offset)(base), RuntimeError, re);
+		        assertErrorMessage(() => this.loadModuleIgnored(type, view, width, offset)(base), RuntimeError, re);
+		        assertErrorMessage(() => this.storeModule(type, view, width, offset)(base), RuntimeError, re);
+		        for ( let op of [ "add", "sub", "and", "or", "xor", "xchg" ]) {
+			    assertErrorMessage(() => this.opModule(type, view, width, offset, op)(base), RuntimeError, re);
+			    assertErrorMessage(() => this.opModuleForEffect(type, view, width, offset, op)(base), RuntimeError, re);
+		        }
+		        assertErrorMessage(() => this.cmpxchgModule(type, view, width, offset)(base), RuntimeError, re);
+		    }
+	        }
+	    }
+        }
+    }
+
+    BoundsAndAlignment.run();
+}
+
+// Bounds and alignment checks on wait and notify
+
+// For 'wait', we check bounds and alignment after sharedness, so the memory
+// must be shared always.
+
+assertErrorMessage(() => wasmEvalText(`(module (memory 1 1 shared)
+					(func (param i32) (result i32)
+					 (i32.atomic.wait (local.get 0) (i32.const 1) (i64.const -1)))
+					(export "" (func 0)))`).exports[""](65536),
+		   RuntimeError, oob);
+
+assertErrorMessage(() => wasmEvalText(`(module (memory 1 1 shared)
+					(func (param i32) (result i32)
+					 (i64.atomic.wait (local.get 0) (i64.const 1) (i64.const -1)))
+					(export "" (func 0)))`).exports[""](65536),
+		   RuntimeError, oob);
+
+assertErrorMessage(() => wasmEvalText(`(module (memory 1 1 shared)
+					(func (param i32) (result i32)
+					 (i32.atomic.wait (local.get 0) (i32.const 1) (i64.const -1)))
+					(export "" (func 0)))`).exports[""](65501),
+		   RuntimeError, unaligned);
+
+assertErrorMessage(() => wasmEvalText(`(module (memory 1 1 shared)
+					(func (param i32) (result i32)
+					 (i64.atomic.wait (local.get 0) (i64.const 1) (i64.const -1)))
+					(export "" (func 0)))`).exports[""](65501),
+		   RuntimeError, unaligned);
+
+// For 'notify', we check bounds and alignment before returning 0 in the case of
+// non-shared memory, so both shared and non-shared memories must be checked.
+
+for ( let shared of ['shared',''] ) {
+    assertErrorMessage(() => wasmEvalText(`(module (memory 1 1 ${shared})
+					(func (param i32) (result i32)
+					 (atomic.notify (local.get 0) (i32.const 1)))
+					(export "" (func 0)))`).exports[""](65536),
+		   RuntimeError, oob);
+
+    // Minimum run-time alignment for NOTIFY is 4
+    for (let addr of [1,2,3,5,6,7]) {
+        assertErrorMessage(() => wasmEvalText(`(module (memory 1 1 ${shared})
+					    (func (export "f") (param i32) (result i32)
+					     (atomic.notify (local.get 0) (i32.const 1))))`).exports.f(addr),
+		           RuntimeError, unaligned);
+    }
+}
+
+// Sharedness check for wait
+
+assertErrorMessage(() => wasmEvalText(`(module (memory 1 1)
+					(func (param i32) (result i32)
+					 (i32.atomic.wait (local.get 0) (i32.const 1) (i64.const -1)))
+					(export "" (func 0)))`).exports[""](0),
+		   RuntimeError, /atomic wait on non-shared memory/);
+
+// Ensure that notify works on non-shared memories and returns zero.
+
+assertEq(wasmEvalText(`
+(module (memory 1 1)
+  (func (export "f") (param i32) (result i32)
+    (atomic.notify (local.get 0) (i32.const 1))))
+`).exports.f(256), 0);
+
+// Ensure alias analysis works even if atomic and non-atomic accesses are
+// mixed.
+assertErrorMessage(() => wasmEvalText(`(module
+  (memory 0 1 shared)
+  (func (export "main")
+    i32.const 1
+    i32.const 2816
+    i32.atomic.rmw16.xchg_u align=2
+    i32.load16_s offset=83 align=1
+    drop
+  )
+)`).exports.main(), RuntimeError, unaligned);
+
+// Make sure we can handle wait and notify without memory
+
+var nomem = /(can't touch memory without memory)|(unknown memory)/;
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (result i32)
+    (atomic.notify (i32.const 0) (i32.const 1))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (result i32)
+    (i32.atomic.wait (i32.const 0) (i32.const 1) (i64.const -1))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (result i32)
+    (i64.atomic.wait (i32.const 0) (i64.const 1) (i64.const -1))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
diff --git a/js/src/jit-test/tests/wasm/atomicity.js b/js/src/jit-test/tests/wasm/atomicity.js
new file mode 100644
index 0000000000..7b071c34ba
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/atomicity.js
@@ -0,0 +1,382 @@
+// Test that wasm atomic operations implement correct mutual exclusion.
+//
+// We have several agents that attempt to hammer on a shared location with rmw
+// operations in such a way that failed atomicity will lead to an incorrect
+// result.  Each agent attempts to clear or set specific bits in a shared datum.
+
+// 1 for a little bit, 2 for a lot, 3 to quit before running tests
+const DEBUG = 0;
+
+// The longer we run, the better, really, but we don't want to time out.
+const ITERATIONS = 100000;
+
+// If you change NUMWORKERS you must also change the tables for INIT, VAL, and
+// RESULT for all the operations, below, by adding or removing bits.
+const NUMWORKERS = 2;
+const NUMAGENTS = NUMWORKERS + 1;
+
+// Need at least one thread per agent.
+
+if (!wasmThreadsEnabled() || helperThreadCount() < NUMWORKERS) {
+    if (DEBUG > 0)
+        print("Threads not supported");
+    quit(0);
+}
+
+// Unless there are enough actual cores the spinning threads will not interact
+// in the desired way (we'll be waiting on preemption to advance), and this
+// makes the test pointless and also will usually make it time out.  So bail out
+// if we can't have one core per agent.
+
+if (getCoreCount() < NUMAGENTS) {
+    if (DEBUG > 0)
+        print("Fake or feeble hardware");
+    quit(0);
+}
+
+// Most of the simulators have poor support for mutual exclusion and are anyway
+// too slow; avoid intermittent failures and timeouts.
+
+let conf = getBuildConfiguration();
+if (conf["arm-simulator"] || conf["arm64-simulator"] ||
+    conf["mips-simulator"] || conf["mips64-simulator"])
+{
+    if (DEBUG > 0)
+        print("Atomicity test disabled on simulator");
+    quit(0);
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+// Coordination code for bootstrapping workers - use spawn() to create a worker,
+// send() to send an item to a worker.  send() will send to anyone, so only one
+// worker should be receiving at a time.  spawn() will block until the worker is
+// running; send() will block until the message has been received.
+
+var COORD_BUSY = 0;
+var COORD_NUMLOC = 1;
+
+var coord = new Int32Array(new SharedArrayBuffer(COORD_NUMLOC*4));
+
+function spawn(text) {
+    text = `
+var _coord = new Int32Array(getSharedObject());
+Atomics.store(_coord, ${COORD_BUSY}, 0);
+function receive() {
+  while (!Atomics.load(_coord, ${COORD_BUSY}))
+      ;
+  let x = getSharedObject();
+  Atomics.store(_coord, ${COORD_BUSY}, 0);
+  return x;
+}
+` + text;
+    setSharedObject(coord.buffer);
+    Atomics.store(coord, COORD_BUSY, 1);
+    evalInWorker(text);
+    while (Atomics.load(coord, COORD_BUSY))
+        ;
+}
+
+function send(x) {
+  while(Atomics.load(coord, COORD_BUSY))
+      ;
+  setSharedObject(x);
+  Atomics.store(coord, COORD_BUSY, 1);
+  while(Atomics.load(coord, COORD_BUSY))
+      ;
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+// The "agents" comprise one master and one or more additional workers.  We make
+// a separate module for each agent so that test values can be inlined as
+// constants.
+//
+// The master initially sets a shared location LOC to a value START.
+//
+// Each agent then operates atomically on LOC with an operation OP and a value
+// VAL.  The operation OP is the same for all agents but each agent `i` has a
+// different VAL_i.
+//
+// To make this more interesting, the value START is distributed as many times
+// through the value at LOC as there is space for, and we perform several
+// operations back-to-back, with the VAL_i appropriately shifted.
+//
+// Each agent then spin-waits for LOC to contain a particular RESULT, which is
+// always (START OP VAL_0 OP VAL_1 ... VAL_k), again repeated throughout the
+// RESULT as appropriate.
+//
+// The process then starts over, and we repeat the process many times.  If we
+// fail to have atomicity at any point the program will hang (LOC will never
+// attain the desired value) and the test should therefore time out.
+//
+// (Barriers are needed to make this all work out.)
+//
+// The general principle for the values is that each VAL should add (or clear) a
+// bit of the stored value.
+//
+// OP       START     VAL0      VAL1      VAL2      RESULT
+//
+// ADD[*]   0         1         2         4         7
+// SUB      7         1         2         4         0
+// AND      7         3         6         5         0
+// OR       0         1         2         4         7
+// XOR      0         1         2         4         7  // or start with 7 and end with 0
+// CMPXCHG  0         1         2         4         7  // use nonatomic "or" to add the bit
+//
+// [*] Running the tests actually assumes that ADD works reasonably well.
+//
+// TODO - more variants we could test:
+//
+// - tests that do not drop the values of the atomic ops but accumulate them:
+//   uses different code generation on x86/x64
+//
+// - Xchg needs a different method, since here the atomic thing is that we read
+//   the "previous value" and set the next value atomically.  How can we observe
+//   that that fails?  If we run three agents, which all set the value to X,
+//   X+1, ..., X+n, with the initial value being (say) X-1, each can record the
+//   value it observed in a table, and we should be able to predict the counts
+//   in that table once postprocessed.  eg, the counts should all be the same.
+//   If atomicity fails then a value is read twice when it shouldn't be, and
+//   some other value is not read at all, and the counts will be off.
+//
+// - the different rmw operations can usually be combined so that we can test
+//   the atomicity of operations that may be implemented differently.
+//
+// - the same tests, with test values as variables instead of constants.
+
+function makeModule(id) {
+    let isMaster = id == 0;
+    let VALSHIFT = NUMAGENTS;      // 1 bit per agent
+
+    function makeLoop(bits, name, op, loc, initial, val, expected) {
+        // Exclude high bit to avoid messing with the sign.
+        let NUMVALS32 = Math.floor(31/VALSHIFT);
+        let NUMVALS = bits == 64 ? 2 * NUMVALS32 : Math.floor(Math.min(bits,31)/VALSHIFT);
+        let BARRIER = "(i32.const 0)";
+        let barrier = `
+  ;; Barrier
+  (local.set $barrierValue (i32.add (local.get $barrierValue) (i32.const ${NUMAGENTS})))
+  (drop (i32.atomic.rmw.add ${BARRIER} (i32.const 1)))
+  (loop $c1
+   (if (i32.lt_s (i32.atomic.load ${BARRIER}) (local.get $barrierValue))
+       (br $c1)))
+  ;; End barrier
+`;
+
+        // Distribute a value `v` across a word NUMVALs times
+
+        function distribute(v) {
+            if (bits <= 32)
+                return '0x' + dist32(v);
+            return '0x' + dist32(v) + dist32(v);
+        }
+
+        function dist32(v) {
+            let n = 0;
+            for (let i=0; i < Math.min(NUMVALS, NUMVALS32); i++)
+                n = n | (v << (i*VALSHIFT));
+            assertEq(n >= 0, true);
+            return (n + 0x100000000).toString(16).substring(1);
+        }
+
+        // Position a value `v` at position `pos` in a word
+
+        function format(val, pos) {
+            if (bits <= 32)
+                return '0x' + format32(val, pos);
+            if (pos < NUMVALS32)
+                return '0x' + '00000000' + format32(val, pos);
+            return '0x' + format32(val, pos - NUMVALS32) + '00000000';
+        }
+
+        function format32(val, pos) {
+            return ((val << (pos * VALSHIFT)) + 0x100000000).toString(16).substring(1);
+        }
+
+        let width = bits < 32 ? '' + bits : '';
+        let view = bits < 32 ? '_u' : '';
+        let prefix = bits == 64 ? 'i64' : 'i32';
+        return `
+ (func ${name} (param $barrierValue i32) (result i32)
+   (local $n i32)
+   (local $tmp ${prefix})
+   (local.set $n (i32.const ${ITERATIONS}))
+   (loop $outer
+    (if (local.get $n)
+        (block
+         ${isMaster ? `;; Init
+(${prefix}.atomic.store${width} ${loc} (${prefix}.const ${distribute(initial)}))` : ``}
+         ${barrier}
+
+${(() => {
+    let s = `;; Do\n`;
+    for (let i=0; i < NUMVALS; i++) {
+        let bitval = `(${prefix}.const ${format(val, i)})`
+        // The load must be atomic though it would be better if it were relaxed,
+        // we would avoid fences in that case.
+        if (op.match(/cmpxchg/)) {
+            s += `(loop $doit
+                   (local.set $tmp (${prefix}.atomic.load${width}${view} ${loc}))
+                   (br_if $doit (i32.eqz
+                                 (${prefix}.eq
+                                  (local.get $tmp)
+                                  (${op} ${loc} (local.get $tmp) (${prefix}.or (local.get $tmp) ${bitval}))))))
+            `;
+        } else {
+            s += `(drop (${op} ${loc} ${bitval}))
+            `;
+       }
+     }
+    return s
+})()}
+         (loop $wait_done
+          (br_if $wait_done (${prefix}.ne (${prefix}.atomic.load${width}${view} ${loc}) (${prefix}.const ${distribute(expected)}))))
+         ${barrier}
+         (local.set $n (i32.sub (local.get $n) (i32.const 1)))
+         (br $outer))))
+  (local.get $barrierValue))`;
+    }
+
+    const ADDLOC = "(i32.const 256)";
+    const ADDINIT = 0;
+    const ADDVAL = [1, 2, 4];
+    const ADDRESULT = 7;
+
+    const SUBLOC = "(i32.const 512)";
+    const SUBINIT = 7;
+    const SUBVAL = [1, 2, 4];
+    const SUBRESULT = 0;
+
+    const ANDLOC = "(i32.const 768)";
+    const ANDINIT = 7;
+    const ANDVAL = [3, 6, 5];
+    const ANDRESULT = 0;
+
+    const ORLOC = "(i32.const 1024)";
+    const ORINIT = 0;
+    const ORVAL = [1, 2, 4];
+    const ORRESULT = 7;
+
+    const XORLOC = "(i32.const 1280)";
+    const XORINIT = 0;
+    const XORVAL = [1, 2, 4];
+    const XORRESULT = 7;
+
+    const CMPXCHGLOC = "(i32.const 1536)";
+    const CMPXCHGINIT = 0;
+    const CMPXCHGVAL = [1, 2, 4];
+    const CMPXCHGRESULT = 7;
+
+    return `
+(module
+ (import "" "memory" (memory 1 1 shared))
+ (import "" "print" (func $print (param i32)))
+
+ ${makeLoop(8, "$test_add8", "i32.atomic.rmw8.add_u", ADDLOC, ADDINIT, ADDVAL[id], ADDRESULT)}
+ ${makeLoop(8, "$test_sub8", "i32.atomic.rmw8.sub_u", SUBLOC, SUBINIT, SUBVAL[id], SUBRESULT)}
+ ${makeLoop(8, "$test_and8", "i32.atomic.rmw8.and_u", ANDLOC, ANDINIT, ANDVAL[id], ANDRESULT)}
+ ${makeLoop(8, "$test_or8", "i32.atomic.rmw8.or_u",   ORLOC, ORINIT, ORVAL[id], ORRESULT)}
+ ${makeLoop(8, "$test_xor8", "i32.atomic.rmw8.xor_u", XORLOC, XORINIT, XORVAL[id], XORRESULT)}
+ ${makeLoop(8, "$test_cmpxchg8", "i32.atomic.rmw8.cmpxchg_u", CMPXCHGLOC, CMPXCHGINIT, CMPXCHGVAL[id], CMPXCHGRESULT)}
+
+ ${makeLoop(16, "$test_add16", "i32.atomic.rmw16.add_u", ADDLOC, ADDINIT, ADDVAL[id], ADDRESULT)}
+ ${makeLoop(16, "$test_sub16", "i32.atomic.rmw16.sub_u", SUBLOC, SUBINIT, SUBVAL[id], SUBRESULT)}
+ ${makeLoop(16, "$test_and16", "i32.atomic.rmw16.and_u", ANDLOC, ANDINIT, ANDVAL[id], ANDRESULT)}
+ ${makeLoop(16, "$test_or16", "i32.atomic.rmw16.or_u",   ORLOC, ORINIT, ORVAL[id], ORRESULT)}
+ ${makeLoop(16, "$test_xor16", "i32.atomic.rmw16.xor_u", XORLOC, XORINIT, XORVAL[id], XORRESULT)}
+ ${makeLoop(16, "$test_cmpxchg16", "i32.atomic.rmw16.cmpxchg_u", CMPXCHGLOC, CMPXCHGINIT, CMPXCHGVAL[id], CMPXCHGRESULT)}
+
+ ${makeLoop(32, "$test_add", "i32.atomic.rmw.add", ADDLOC, ADDINIT, ADDVAL[id], ADDRESULT)}
+ ${makeLoop(32, "$test_sub", "i32.atomic.rmw.sub", SUBLOC, SUBINIT, SUBVAL[id], SUBRESULT)}
+ ${makeLoop(32, "$test_and", "i32.atomic.rmw.and", ANDLOC, ANDINIT, ANDVAL[id], ANDRESULT)}
+ ${makeLoop(32, "$test_or", "i32.atomic.rmw.or",   ORLOC, ORINIT, ORVAL[id], ORRESULT)}
+ ${makeLoop(32, "$test_xor", "i32.atomic.rmw.xor", XORLOC, XORINIT, XORVAL[id], XORRESULT)}
+ ${makeLoop(32, "$test_cmpxchg", "i32.atomic.rmw.cmpxchg", CMPXCHGLOC, CMPXCHGINIT, CMPXCHGVAL[id], CMPXCHGRESULT)}
+
+ ${makeLoop(64, "$test_add64", "i64.atomic.rmw.add", ADDLOC, ADDINIT, ADDVAL[id], ADDRESULT)}
+ ${makeLoop(64, "$test_sub64", "i64.atomic.rmw.sub", SUBLOC, SUBINIT, SUBVAL[id], SUBRESULT)}
+ ${makeLoop(64, "$test_and64", "i64.atomic.rmw.and", ANDLOC, ANDINIT, ANDVAL[id], ANDRESULT)}
+ ${makeLoop(64, "$test_or64", "i64.atomic.rmw.or",   ORLOC, ORINIT, ORVAL[id], ORRESULT)}
+ ${makeLoop(64, "$test_xor64", "i64.atomic.rmw.xor", XORLOC, XORINIT, XORVAL[id], XORRESULT)}
+ ${makeLoop(64, "$test_cmpxchg64", "i64.atomic.rmw.cmpxchg", CMPXCHGLOC, CMPXCHGINIT, CMPXCHGVAL[id], CMPXCHGRESULT)}
+
+ (func (export "test")
+  (local $barrierValue i32)
+  (call $print (i32.const ${10 + id}))
+  (local.set $barrierValue (call $test_add8 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_sub8 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_and8 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_or8 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_xor8 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_cmpxchg8 (local.get $barrierValue)))
+  (call $print (i32.const ${20 + id}))
+  (local.set $barrierValue (call $test_add16 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_sub16 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_and16 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_or16 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_xor16 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_cmpxchg16 (local.get $barrierValue)))
+  (call $print (i32.const ${30 + id}))
+  (local.set $barrierValue (call $test_add (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_sub (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_and (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_or (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_xor (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_cmpxchg (local.get $barrierValue)))
+  (call $print (i32.const ${40 + id}))
+  (local.set $barrierValue (call $test_add64 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_sub64 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_and64 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_or64 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_xor64 (local.get $barrierValue)))
+  (local.set $barrierValue (call $test_cmpxchg64 (local.get $barrierValue)))
+ ))
+`;
+}
+
+function makeModule2(id) {
+    let text = makeModule(id);
+    if (DEBUG > 1)
+        print(text);
+    return new WebAssembly.Module(wasmTextToBinary(text));
+}
+
+var mods = [];
+mods.push(makeModule2(0));
+for ( let i=0; i < NUMWORKERS; i++ )
+    mods.push(makeModule2(i+1));
+if (DEBUG > 2)
+    quit(0);
+var mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared: true});
+
+////////////////////////////////////////////////////////////////////////
+//
+// Worker code
+
+function startWorkers() {
+    for ( let i=0; i < NUMWORKERS; i++ ) {
+        spawn(`
+var mem = receive();
+var mod = receive();
+function pr(n) { if (${DEBUG}) print(n); }
+var ins = new WebAssembly.Instance(mod, {"":{memory: mem, print:pr}});
+if (${DEBUG} > 0)
+    print("Running ${i}");
+ins.exports.test();
+              `);
+        send(mem);
+        send(mods[i+1]);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////
+//
+// Main thread code
+
+startWorkers();
+function pr(n) { if (DEBUG) print(n); }
+var ins = new WebAssembly.Instance(mods[0], {"":{memory: mem, print:pr}});
+if (DEBUG > 0)
+    print("Running master");
+ins.exports.test();
diff --git a/js/src/jit-test/tests/wasm/backtrace.js b/js/src/jit-test/tests/wasm/backtrace.js
new file mode 100644
index 0000000000..ea3825ab92
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/backtrace.js
@@ -0,0 +1,21 @@
+var code = `(module
+  (import "env" "test" (func $i))
+  (func $t (call $i))
+  (export "test" (func $t))
+)`;
+var mod = wasmEvalText(code, {
+  env: {
+    test: function() {
+       // Expecting 3 lines in the backtrace (plus last empty).
+       // The middle one is for the wasm function.
+       var s = getBacktrace();
+       var frames = s.split('\n');
+       assertEq(frames.length, 4);
+       assertEq(/> WebAssembly.Module":wasm-function\[1\]:0x/.test(frames[1]), true);
+
+       // Let's also run DumpBacktrace() to check if we are not crashing.
+       backtrace();
+    }
+  }
+}).exports;
+mod.test();
diff --git a/js/src/jit-test/tests/wasm/baseline-abs-addr-opt.js b/js/src/jit-test/tests/wasm/baseline-abs-addr-opt.js
new file mode 100644
index 0000000000..49528ce37c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/baseline-abs-addr-opt.js
@@ -0,0 +1,94 @@
+// Test bounds checking at the end of memory with a constant base pointer.
+// This is intended to verify a bounds check elimination optimization in
+// the baseline compiler.
+
+// This can be only a functional test, we can't really see whether
+// the optimization is being applied.  However, manual inspection
+// of the generated code has verified that the optimization is
+// being applied.
+
+// Memory is one page and minimum memory is one page, so accesses across
+// the end of the first page should fail.
+
+function gen(base, offset) {
+  return wasmEvalText(`(module
+			(memory 1)
+			(data (i32.const 65528) "aaaaaaaa")
+			(func (result i32)
+			 (i32.load offset=${offset} (i32.const ${base})))
+			(export "f" (func 0)))`).exports["f"];
+}
+
+// Memory is two pages but minimum memory is one page, so accesses across
+// the end of the first page should succeed.
+
+function gen2(base, offset) {
+  return wasmEvalText(`(module
+			(memory 1)
+			(data (i32.const 65528) "aaaaaaaa")
+			(func (result i32)
+			 (drop (memory.grow (i32.const 1)))
+			 (i32.store (i32.const 65536) (i32.const 0x61616161))
+			 (i32.store (i32.const 65540) (i32.const 0x61616161))
+			 (i32.store (i32.const 80000) (i32.const 0x61616161))
+			 (i32.store (i32.const 120000) (i32.const 0x61616161))
+			 (i32.load offset=${offset} (i32.const ${base})))
+			(export "f" (func 0)))`).exports["f"];
+}
+
+// Access the first page.
+// None of these should have an explicit bounds check generated for them as the
+// effective address is less than the sum of the minimum heap length and the
+// offset guard length.
+
+let onfirst = [[4,65528], [3,65528], [2,65528], [1,65528], [0,65528],
+	       [3,65529], [2,65529], [1,65529], [0,65529],
+	       [2,65530], [1,65530], [0,65530],
+	       [1,65531], [0,65531],
+	       [0,65532],
+	       [256, 65536-256-4],
+	       [2048, 65536-2048-4],
+	       [30000, 65536-30000-4]];
+
+for ( let [x,y] of onfirst ) {
+  assertEq(gen(x,y)(), 0x61616161|0);
+  assertEq(gen(y,x)(), 0x61616161|0);
+}
+
+// Access the second page.
+// Again, no explicit bounds checks should be generated here.
+
+let onsecond = [[65532,1], [65532,2], [65532,3], [65532,4], [65532,5], [65532,6], [65532,7], [65532,8],
+		[65531,2], [65531,3], [65531,4], [65531,5], [65531,6], [65531,7], [65531,8], [65531,9],
+		[65530,3], [65530,4], [65530,5], [65530,6], [65530,7], [65530,8], [65530,9], [65530,10],
+		[65529,4], [65529,5], [65529,6], [65529,7], [65529,8], [65529,9], [65529,10], [65529,11],
+		[65528,5], [65528,6], [65528,7], [65528,8], [65528,9], [65528,10], [65528,11], [65528,12],
+		[65527,6], [65527,7], [65527,8], [65527,9], [65527,10], [65527,11], [65527,12], [65527,13],
+		[65526,7], [65526,8], [65526,9], [65526,10], [65526,11], [65526,12], [65526,13], [65526,14],
+		[65525,8], [65525,9], [65525,10], [65525,11], [65525,12], [65525,13], [65525,14], [65525,15],
+		[256, 65536-256],
+		[2048, 65536-2048],
+		[30000, 50000],
+		[30000, 90000]];
+
+for ( let [x,y] of onsecond ) {
+  assertErrorMessage(() => { gen(x,y)() }, WebAssembly.RuntimeError, /index out of bounds/);
+  assertErrorMessage(() => { gen(y,x)() }, WebAssembly.RuntimeError, /index out of bounds/);
+
+  assertEq(gen2(x,y)(), 0x61616161|0);
+  assertEq(gen2(y,x)(), 0x61616161|0);
+}
+
+// Access the third page.
+// Here the explicit bounds check cannot be omitted, as the access is
+// beyond min + offset guard.
+
+let onthird = [[60000, 90000]];
+
+for ( let [x,y] of onthird ) {
+  assertErrorMessage(() => { gen(x,y)() }, WebAssembly.RuntimeError, /index out of bounds/);
+  assertErrorMessage(() => { gen(y,x)() }, WebAssembly.RuntimeError, /index out of bounds/);
+
+  assertErrorMessage(() => { gen2(x,y)() }, WebAssembly.RuntimeError, /index out of bounds/);
+  assertErrorMessage(() => { gen2(y,x)() }, WebAssembly.RuntimeError, /index out of bounds/);
+}
diff --git a/js/src/jit-test/tests/wasm/baseline-opt.js b/js/src/jit-test/tests/wasm/baseline-opt.js
new file mode 100644
index 0000000000..4cd06be319
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/baseline-opt.js
@@ -0,0 +1,108 @@
+// Point-testing various optimizations in the wasm baseline compiler.
+
+// Boolean optimization for control (bug 1286816).
+//
+// These optimizations combine a test (a comparison or Eqz) with an
+// immediately following conditional branch (BrIf, If, and Select), to
+// avoid generating a boolean value that is then tested with a
+// compare-to-zero.
+//
+// On AngryBots as of November 2016, 84% of all test instructions
+// (measured statically) are optimized by this method.
+
+function testEqzBrIf(value, type, untaken, taken, expected) {
+    var f = wasmEvalText(`(module
+			   (func (result i32)
+			    (local ${type})
+			    (local i32)
+			    (local.set 0 (${type}.const ${value}))
+			    (local.set 1 (i32.const ${taken}))
+			    (block $b
+			     (br_if $b (${type}.eqz (local.get 0)))
+			     (local.set 1 (i32.const ${untaken})))
+			    (local.get 1))
+			   (export "f" (func 0)))`).exports["f"];
+    assertEq(f(), expected);
+}
+
+["i32", "i64"].forEach(t => testEqzBrIf(0, t, 37, 42, 42)); // Taken
+["i32", "i64"].forEach(t => testEqzBrIf(1, t, 37, 42, 37)); // Untaken
+
+function testCmpBrIf(value, type, untaken, taken, expected) {
+    var f = wasmEvalText(`(module
+			   (func (result i32)
+			    (local ${type})
+			    (local i32)
+			    (local.set 1 (i32.const ${taken}))
+			    (block $b
+			     (br_if $b (${type}.eq (local.get 0) (${type}.const ${value})))
+			     (local.set 1 (i32.const ${untaken})))
+			    (local.get 1))
+			   (export "f" (func 0)))`).exports["f"];
+    assertEq(f(), expected);
+}
+
+["i32", "i64", "f32", "f64"].forEach(t => testCmpBrIf(0, t, 37, 42, 42)); // Branch taken
+["i32", "i64", "f32", "f64"].forEach(t => testCmpBrIf(1, t, 37, 42, 37)); // Branch untaken
+
+function testEqzSelect(value, type, iftrue, iffalse, expected) {
+    var f = wasmEvalText(`(module
+			   (func (result i32)
+			    (local ${type})
+			    (local.set 0 (${type}.const ${value}))
+			    (select (i32.const ${iftrue})
+			            (i32.const ${iffalse})
+			            (${type}.eqz (local.get 0))))
+			   (export "f" (func 0)))`).exports["f"];
+    assertEq(f(), expected);
+}
+
+["i32", "i64"].forEach(t => testEqzSelect(0, t, 42, 37, 42)); // Select first
+["i32", "i64"].forEach(t => testEqzSelect(1, t, 42, 37, 37)); // Select second
+
+function testCmpSelect(value, type, iftrue, iffalse, expected) {
+    var f = wasmEvalText(`(module
+			   (func (result i32)
+			    (local ${type})
+			    (select (i32.const ${iftrue})
+			            (i32.const ${iffalse})
+			            (${type}.eq (local.get 0) (${type}.const ${value}))))
+			   (export "f" (func 0)))`).exports["f"];
+    assertEq(f(), expected);
+}
+
+["i32", "i64", "f32", "f64"].forEach(t => testCmpSelect(0, t, 42, 37, 42)); // Select first
+["i32", "i64", "f32", "f64"].forEach(t => testCmpSelect(1, t, 42, 37, 37)); // Select second
+
+function testEqzIf(value, type, trueBranch, falseBranch, expected) {
+    var f = wasmEvalText(`(module
+			   (func (result i32)
+			    (local ${type})
+			    (local i32)
+			    (local.set 0 (${type}.const ${value}))
+			    (if (${type}.eqz (local.get 0))
+				(local.set 1 (i32.const ${trueBranch}))
+			        (local.set 1 (i32.const ${falseBranch})))
+			    (local.get 1))
+			   (export "f" (func 0)))`).exports["f"];
+    assertEq(f(), expected);
+}
+
+["i32", "i64"].forEach(t => testEqzIf(0, t, 42, 37, 42)); // Taken
+["i32", "i64"].forEach(t => testEqzIf(1, t, 42, 37, 37)); // Untaken
+
+function testCmpIf(value, type, trueBranch, falseBranch, expected) {
+    var f = wasmEvalText(`(module
+			   (func (result i32)
+			    (local ${type})
+			    (local i32)
+			    (if (${type}.eq (local.get 0) (${type}.const ${value}))
+				(local.set 1 (i32.const ${trueBranch}))
+			        (local.set 1 (i32.const ${falseBranch})))
+			    (local.get 1))
+			   (export "f" (func 0)))`).exports["f"];
+    assertEq(f(), expected);
+}
+
+["i32", "i64", "f32", "f64"].forEach(t => testCmpIf(0, t, 42, 37, 42)); // Taken
+["i32", "i64", "f32", "f64"].forEach(t => testCmpIf(1, t, 42, 37, 37)); // Untaken
diff --git a/js/src/jit-test/tests/wasm/basic.js b/js/src/jit-test/tests/wasm/basic.js
new file mode 100644
index 0000000000..4c775fbe6c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/basic.js
@@ -0,0 +1,362 @@
+const { LinkError } = WebAssembly;
+
+// ----------------------------------------------------------------------------
+// exports
+
+var o = wasmEvalText('(module)').exports;
+assertEq(Object.getOwnPropertyNames(o).length, 0);
+
+var o = wasmEvalText('(module (func))').exports;
+assertEq(Object.getOwnPropertyNames(o).length, 0);
+
+var o = wasmEvalText('(module (func) (export "a" (func 0)))').exports;
+var names = Object.getOwnPropertyNames(o);
+assertEq(names.length, 1);
+assertEq(names[0], 'a');
+var desc = Object.getOwnPropertyDescriptor(o, 'a');
+assertEq(typeof desc.value, "function");
+assertEq(desc.value.name, "0");
+assertEq(desc.value.length, 0);
+assertEq(desc.value(), undefined);
+assertEq(desc.writable, false);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, false);
+assertEq(desc.value(), undefined);
+
+wasmValidateText('(module (func) (func) (export "a" (func 0)))');
+wasmValidateText('(module (func) (func) (export "a" (func 1)))');
+wasmValidateText('(module (func $a) (func $b) (export "a" (func $a)) (export "b" (func $b)))');
+wasmValidateText('(module (func $a) (func $b) (export "a" (func $a)) (export "b" (func $b)))');
+
+wasmFailValidateText('(module (func) (export "a" (func 1)))', /exported function index out of bounds/);
+wasmFailValidateText('(module (func) (func) (export "a" (func 2)))', /exported function index out of bounds/);
+
+var o = wasmEvalText('(module (func) (export "a" (func 0)) (export "b" (func 0)))').exports;
+assertEq(Object.getOwnPropertyNames(o).sort().toString(), "a,b");
+assertEq(o.a.name, "0");
+assertEq(o.b.name, "0");
+assertEq(o.a === o.b, true);
+
+var o = wasmEvalText('(module (func) (func) (export "a" (func 0)) (export "b" (func 1)))').exports;
+assertEq(Object.getOwnPropertyNames(o).sort().toString(), "a,b");
+assertEq(o.a.name, "0");
+assertEq(o.b.name, "1");
+assertEq(o.a === o.b, false);
+
+var o = wasmEvalText('(module (func (result i32) (i32.const 1)) (func (result i32) (i32.const 2)) (export "a" (func 0)) (export "b" (func 1)))').exports;
+assertEq(o.a(), 1);
+assertEq(o.b(), 2);
+var o = wasmEvalText('(module (func (result i32) (i32.const 1)) (func (result i32) (i32.const 2)) (export "a" (func 1)) (export "b" (func 0)))').exports;
+assertEq(o.a(), 2);
+assertEq(o.b(), 1);
+
+wasmFailValidateText('(module (func) (export "a" (func 0)) (export "a" (func 0)))', /duplicate export/);
+wasmFailValidateText('(module (func) (func) (export "a" (func 0)) (export "a" (func 1)))', /duplicate export/);
+
+// ----------------------------------------------------------------------------
+// signatures
+
+wasmFailValidateText('(module (func (result i32)))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (nop)))', emptyStackError);
+
+wasmValidateText('(module (func (nop)))');
+wasmValidateText('(module (func (result i32) (i32.const 42)))');
+wasmValidateText('(module (func (param i32)))');
+wasmValidateText('(module (func (param i32) (result i32) (i32.const 42)))');
+wasmValidateText('(module (func (param i32) (result i32) (i32.const 42)))');
+wasmValidateText('(module (func (param f32)))');
+wasmValidateText('(module (func (param f64)))');
+
+wasmFullPassI64('(module (func $run (result i64) (i64.const 123)))', 123);
+wasmFullPassI64('(module (func $run (param i64) (result i64) (local.get 0)))',
+                '0x123400007fffffff',
+                {},
+                '(i64.const 0x123400007fffffff)');
+wasmFullPassI64('(module (func $run (param i64) (result i64) (i64.add (local.get 0) (i64.const 1))))',
+                '0x1234000100000000',
+                {},
+                '(i64.const 0x12340000ffffffff)');
+
+// ----------------------------------------------------------------------------
+// imports
+
+const noImportObj = "second argument must be an object";
+
+assertErrorMessage(() => wasmEvalText('(module (import "a" "b" (func)))', 1), TypeError, noImportObj);
+assertErrorMessage(() => wasmEvalText('(module (import "a" "b" (func)))', null), TypeError, noImportObj);
+
+const notObject = /import object field '\w*' is not an Object/;
+const notFunction = /import object field '\w*' is not a Function/;
+
+var code = '(module (import "a" "b" (func)))';
+assertErrorMessage(() => wasmEvalText(code), TypeError, noImportObj);
+assertErrorMessage(() => wasmEvalText(code, {}), TypeError, notObject);
+assertErrorMessage(() => wasmEvalText(code, {a:1}), TypeError, notObject);
+assertErrorMessage(() => wasmEvalText(code, {a:{}}), LinkError, notFunction);
+assertErrorMessage(() => wasmEvalText(code, {a:{b:1}}), LinkError, notFunction);
+wasmEvalText(code, {a:{b:()=>{}}});
+
+var code = '(module (import "" "b" (func)))';
+wasmEvalText(code, {"":{b:()=>{}}});
+
+var code = '(module (import "a" "" (func)))';
+assertErrorMessage(() => wasmEvalText(code), TypeError, noImportObj);
+assertErrorMessage(() => wasmEvalText(code, {}), TypeError, notObject);
+assertErrorMessage(() => wasmEvalText(code, {a:1}), TypeError, notObject);
+wasmEvalText(code, {a:{"":()=>{}}});
+
+var code = '(module (import "a" "" (func)) (import "b" "c" (func)) (import "c" "" (func)))';
+assertErrorMessage(() => wasmEvalText(code, {a:()=>{}, b:{c:()=>{}}, c:{}}), LinkError, notFunction);
+wasmEvalText(code, {a:{"":()=>{}}, b:{c:()=>{}}, c:{"":()=>{}}});
+
+wasmEvalText('(module (import "a" "" (func (result i32))))', {a:{"":()=>{}}});
+wasmEvalText('(module (import "a" "" (func (result f32))))', {a:{"":()=>{}}});
+wasmEvalText('(module (import "a" "" (func (result f64))))', {a:{"":()=>{}}});
+wasmEvalText('(module (import "a" "" (func $foo (result f64))))', {a:{"":()=>{}}});
+
+// ----------------------------------------------------------------------------
+// memory
+
+wasmValidateText('(module (memory 0))');
+wasmValidateText('(module (memory 1))');
+
+var buf = wasmEvalText('(module (memory 1) (export "memory" (memory 0)))').exports.memory.buffer;
+assertEq(buf instanceof ArrayBuffer, true);
+assertEq(buf.byteLength, 65536);
+
+var obj = wasmEvalText('(module (memory 1) (func (result i32) (i32.const 42)) (func (nop)) (export "memory" (memory 0)) (export "b" (func 0)) (export "c" (func 1)))').exports;
+assertEq(obj.memory.buffer instanceof ArrayBuffer, true);
+assertEq(obj.b instanceof Function, true);
+assertEq(obj.c instanceof Function, true);
+assertEq(obj.memory.buffer.byteLength, 65536);
+assertEq(obj.b(), 42);
+assertEq(obj.c(), undefined);
+
+var buf = wasmEvalText('(module (memory 1) (data (i32.const 0) "") (export "memory" (memory 0)))').exports.memory.buffer;
+assertEq(new Uint8Array(buf)[0], 0);
+
+var buf = wasmEvalText('(module (memory 1) (data (i32.const 65536) "") (export "memory" (memory 0)))').exports.memory.buffer;
+assertEq(new Uint8Array(buf)[0], 0);
+
+var buf = wasmEvalText('(module (memory 1) (data (i32.const 0) "a") (export "memory" (memory 0)))').exports.memory.buffer;
+assertEq(new Uint8Array(buf)[0], 'a'.charCodeAt(0));
+
+var buf = wasmEvalText('(module (memory 1) (data (i32.const 0) "a") (data (i32.const 2) "b") (export "memory" (memory 0)))').exports.memory.buffer;
+assertEq(new Uint8Array(buf)[0], 'a'.charCodeAt(0));
+assertEq(new Uint8Array(buf)[1], 0);
+assertEq(new Uint8Array(buf)[2], 'b'.charCodeAt(0));
+
+var buf = wasmEvalText('(module (memory 1) (data (i32.const 65535) "c") (export "memory" (memory 0)))').exports.memory.buffer;
+assertEq(new Uint8Array(buf)[0], 0);
+assertEq(new Uint8Array(buf)[65535], 'c'.charCodeAt(0));
+
+// ----------------------------------------------------------------------------
+// locals
+
+assertEq(wasmEvalText('(module (func (param i32) (result i32) (local.get 0)) (export "" (func 0)))').exports[""](), 0);
+assertEq(wasmEvalText('(module (func (param i32) (result i32) (local.get 0)) (export "" (func 0)))').exports[""](42), 42);
+assertEq(wasmEvalText('(module (func (param i32) (param i32) (result i32) (local.get 0)) (export "" (func 0)))').exports[""](42, 43), 42);
+assertEq(wasmEvalText('(module (func (param i32) (param i32) (result i32) (local.get 1)) (export "" (func 0)))').exports[""](42, 43), 43);
+
+wasmFailValidateText('(module (func (local.get 0)))', /(local.get index out of range)|(local index out of bounds)/);
+wasmFailValidateText('(module (func (result f32) (local i32) (local.get 0)))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (result i32) (local f32) (local.get 0)))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (result f32) (local f32) (local.get 0)))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param i32) (result i32) (local f32) (local.get 1)))', mismatchError("f32", "i32"));
+
+wasmValidateText('(module (func (local i32)))');
+wasmValidateText('(module (func (local i32) (local f32)))');
+
+wasmFullPass('(module (func (result i32) (local i32) (local.get 0)) (export "run" (func 0)))', 0);
+wasmFullPass('(module (func (param i32) (result i32) (local f32) (local.get 0)) (export "run" (func 0)))', 0);
+wasmFullPass('(module (func (param i32) (result f32) (local f32) (local.get 1)) (export "run" (func 0)))', 0);
+
+wasmFailValidateText('(module (func (local.set 0 (i32.const 0))))', /(local.set index out of range)|(local index out of bounds)/);
+wasmFailValidateText('(module (func (local f32) (local.set 0 (i32.const 0))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (local f32) (local.set 0 (nop))))', emptyStackError);
+wasmFailValidateText('(module (func (local i32) (local f32) (local.set 0 (local.get 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (local i32) (local f32) (local.set 1 (local.get 0))))', mismatchError("i32", "f32"));
+
+wasmValidateText('(module (func (local i32) (local.set 0 (i32.const 0))))');
+wasmValidateText('(module (func (local i32) (local f32) (local.set 0 (local.get 0))))');
+wasmValidateText('(module (func (local i32) (local f32) (local.set 1 (local.get 1))))');
+
+wasmFullPass('(module (func (result i32) (local i32) (tee_local 0 (i32.const 42))) (export "run" (func 0)))', 42);
+wasmFullPass('(module (func (result i32) (local i32) (tee_local 0 (local.get 0))) (export "run" (func 0)))', 0);
+
+wasmFullPass('(module (func (param $a i32) (result i32) (local.get $a)) (export "run" (func 0)))', 0);
+wasmFullPass('(module (func (param $a i32) (result i32) (local $b i32) (block (result i32) (local.set $b (local.get $a)) (local.get $b))) (export "run" (func 0)))', 42, {}, 42);
+
+wasmValidateText('(module (func (local i32) (local $a f32) (local.set 0 (i32.const 1)) (local.set $a (f32.const nan))))');
+
+// ----------------------------------------------------------------------------
+// blocks
+
+wasmFullPass('(module (func (block )) (export "run" (func 0)))', undefined);
+
+wasmFailValidateText('(module (func (result i32) (block )))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (block (block ))))', emptyStackError);
+wasmFailValidateText('(module (func (local i32) (local.set 0 (block ))))', emptyStackError);
+
+wasmFullPass('(module (func (block (block ))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (result i32) (block (result i32) (i32.const 42))) (export "run" (func 0)))', 42);
+wasmFullPass('(module (func (result i32) (block (result i32) (block (result i32) (i32.const 42)))) (export "run" (func 0)))', 42);
+wasmFailValidateText('(module (func (result f32) (block (result i32) (i32.const 0))))', mismatchError("i32", "f32"));
+
+wasmFullPass('(module (func (result i32) (block (result i32) (drop (i32.const 13)) (block (result i32) (i32.const 42)))) (export "run" (func 0)))', 42);
+wasmFailValidateText('(module (func (param f32) (result f32) (block (result i32) (drop (local.get 0)) (i32.const 0))))', mismatchError("i32", "f32"));
+
+wasmFullPass('(module (func (result i32) (local i32) (local.set 0 (i32.const 42)) (local.get 0)) (export "run" (func 0)))', 42);
+
+// ----------------------------------------------------------------------------
+// calls
+
+wasmFailValidateText('(module (func (nop)) (func (call 0 (i32.const 0))))', unusedValuesError);
+
+wasmFailValidateText('(module (func (param i32) (nop)) (func (call 0)))', emptyStackError);
+wasmFailValidateText('(module (func (param f32) (nop)) (func (call 0 (i32.const 0))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (nop)) (func (call 3)))', /(callee index out of range)|(function index out of bounds)/);
+
+wasmValidateText('(module (func (nop)) (func (call 0)))');
+wasmValidateText('(module (func (param i32) (nop)) (func (call 0 (i32.const 0))))');
+
+wasmFullPass('(module (func (result i32) (i32.const 42)) (func (result i32) (call 0)) (export "run" (func 1)))', 42);
+assertThrowsInstanceOf(() => wasmEvalText('(module (func (call 0)) (export "" (func 0)))').exports[""](), InternalError);
+assertThrowsInstanceOf(() => wasmEvalText('(module (func (call 1)) (func (call 0)) (export "" (func 0)))').exports[""](), InternalError);
+
+wasmValidateText('(module (func (param i32 f32)) (func (call 0 (i32.const 0) (f32.const nan))))');
+wasmFailValidateText('(module (func (param i32 f32)) (func (call 0 (i32.const 0) (i32.const 0))))', mismatchError("i32", "f32"));
+
+wasmFailValidateText('(module (import "a" "" (func)) (func (call 0 (i32.const 0))))', unusedValuesError);
+wasmFailValidateText('(module (import "a" "" (func (param i32))) (func (call 0)))', emptyStackError);
+wasmFailValidateText('(module (import "a" "" (func (param f32))) (func (call 0 (i32.const 0))))', mismatchError("i32", "f32"));
+
+assertErrorMessage(() => wasmEvalText('(module (import "a" "" (func)) (func (call 1)))'), TypeError, noImportObj);
+wasmEvalText('(module (import "" "a" (func)) (func (call 0)))', {"":{a:()=>{}}});
+wasmEvalText('(module (import "" "a" (func (param i32))) (func (call 0 (i32.const 0))))', {"":{a:()=>{}}});
+
+function checkF32CallImport(v) {
+    wasmFullPass('(module (import "" "a" (func (result f32))) (func (result f32) (call 0)) (export "run" (func 1)))',
+                 Math.fround(v),
+                 {"":{a:()=>{ return v; }}});
+    wasmFullPass('(module (import "" "a" (func (param f32))) (func (param f32) (call 0 (local.get 0))) (export "run" (func 1)))',
+                 undefined,
+                 {"":{a:x=>{ assertEq(Math.fround(v), x); }}},
+                 v);
+}
+checkF32CallImport(13.37);
+checkF32CallImport(NaN);
+checkF32CallImport(-Infinity);
+checkF32CallImport(-0);
+checkF32CallImport(Math.pow(2, 32) - 1);
+
+var counter = 0;
+var f = wasmEvalText('(module (import "" "inc" (func)) (func (call 0)) (export "" (func 1)))', {"":{inc:()=>counter++}}).exports[""];
+var g = wasmEvalText('(module (import "" "f" (func)) (func (block (call 0) (call 0))) (export "" (func 1)))', {"":{f}}).exports[""];
+f();
+assertEq(counter, 1);
+g();
+assertEq(counter, 3);
+
+var f = wasmEvalText('(module (import "" "callf" (func)) (func (call 0)) (export "" (func 1)))', {"":{callf:()=>f()}}).exports[""];
+assertThrowsInstanceOf(() => f(), InternalError);
+
+var f = wasmEvalText('(module (import "" "callg" (func)) (func (call 0)) (export "" (func 1)))', {"":{callg:()=>g()}}).exports[""];
+var g = wasmEvalText('(module (import "" "callf" (func)) (func (call 0)) (export "" (func 1)))', {"":{callf:()=>f()}}).exports[""];
+assertThrowsInstanceOf(() => f(), InternalError);
+
+var code = '(module (import "" "one" (func (result i32))) (import "" "two" (func (result i32))) (func (result i32) (i32.const 3)) (func (result i32) (i32.const 4)) (func (result i32) BODY) (export "run" (func 4)))';
+var imports = {"":{one:()=>1, two:()=>2}};
+wasmFullPass(code.replace('BODY', '(call 0)'), 1, imports);
+wasmFullPass(code.replace('BODY', '(call 1)'), 2, imports);
+wasmFullPass(code.replace('BODY', '(call 2)'), 3, imports);
+wasmFullPass(code.replace('BODY', '(call 3)'), 4, imports);
+
+wasmFullPass(`(module (import "" "evalcx" (func (param i32) (result i32))) (func (result i32) (call 0 (i32.const 0))) (export "run" (func 1)))`, 0, {"":{evalcx}});
+
+if (typeof evaluate === 'function')
+    evaluate(`new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module)'))) `, { fileName: null });
+
+wasmFailValidateText(`(module (type $t (func)) (func (call_indirect (type $t) (i32.const 0))))`, /(can't call_indirect without a table)|(unknown table)/);
+
+var {v2i, i2i, i2v} = wasmEvalText(`(module
+    (type (func (result i32)))
+    (type (func (param i32) (result i32)))
+    (type (func (param i32)))
+    (func (type 0) (i32.const 13))
+    (func (type 0) (i32.const 42))
+    (func (type 1) (i32.add (local.get 0) (i32.const 1)))
+    (func (type 1) (i32.add (local.get 0) (i32.const 2)))
+    (func (type 1) (i32.add (local.get 0) (i32.const 3)))
+    (func (type 1) (i32.add (local.get 0) (i32.const 4)))
+    (table funcref (elem 0 1 2 3 4 5))
+    (func (param i32) (result i32) (call_indirect (type 0) (local.get 0)))
+    (func (param i32) (param i32) (result i32) (call_indirect (type 1) (local.get 1) (local.get 0)))
+    (func (param i32) (call_indirect (type 2) (i32.const 0) (local.get 0)))
+    (export "v2i" (func 6))
+    (export "i2i" (func 7))
+    (export "i2v" (func 8))
+)`).exports;
+
+const signatureMismatch = /indirect call signature mismatch/;
+
+assertEq(v2i(0), 13);
+assertEq(v2i(1), 42);
+assertErrorMessage(() => v2i(2), Error, signatureMismatch);
+assertErrorMessage(() => v2i(3), Error, signatureMismatch);
+assertErrorMessage(() => v2i(4), Error, signatureMismatch);
+assertErrorMessage(() => v2i(5), Error, signatureMismatch);
+
+assertErrorMessage(() => i2i(0), Error, signatureMismatch);
+assertErrorMessage(() => i2i(1), Error, signatureMismatch);
+assertEq(i2i(2, 100), 101);
+assertEq(i2i(3, 100), 102);
+assertEq(i2i(4, 100), 103);
+assertEq(i2i(5, 100), 104);
+
+assertErrorMessage(() => i2v(0), Error, signatureMismatch);
+assertErrorMessage(() => i2v(1), Error, signatureMismatch);
+assertErrorMessage(() => i2v(2), Error, signatureMismatch);
+assertErrorMessage(() => i2v(3), Error, signatureMismatch);
+assertErrorMessage(() => i2v(4), Error, signatureMismatch);
+assertErrorMessage(() => i2v(5), Error, signatureMismatch);
+
+{
+    enableGeckoProfiling();
+
+    var stack;
+    wasmFullPass(
+        `(module
+            (type $v2v (func))
+            (import "" "f" (func $foo))
+            (func $a (call $foo))
+            (func $b (result i32) (i32.const 0))
+            (table funcref (elem $a $b))
+            (func $bar (call_indirect (type $v2v) (i32.const 0)))
+            (export "run" (func $bar))
+        )`,
+        undefined,
+        {"":{f:() => { stack = new Error().stack }}}
+    );
+
+    disableGeckoProfiling();
+
+    var inner = stack.indexOf("wasm-function[1]");
+    var outer = stack.indexOf("wasm-function[3]");
+    assertEq(inner === -1, false);
+    assertEq(outer === -1, false);
+    assertEq(inner < outer, true);
+}
+
+for (bad of [6, 7, 100, Math.pow(2,31)-1, Math.pow(2,31), Math.pow(2,31)+1, Math.pow(2,32)-2, Math.pow(2,32)-1]) {
+    assertThrowsInstanceOf(() => v2i(bad), WebAssembly.RuntimeError);
+    assertThrowsInstanceOf(() => i2i(bad, 0), WebAssembly.RuntimeError);
+    assertThrowsInstanceOf(() => i2v(bad, 0), WebAssembly.RuntimeError);
+}
+
+wasmValidateText('(module (func $foo (nop)) (func (call $foo)))');
+wasmValidateText('(module (func (call $foo)) (func $foo (nop)))');
+wasmValidateText('(module (import "" "a" (func $bar)) (func (call $bar)) (func $foo (nop)))');
+
+var exp = wasmEvalText(`(module (func (export "f")))`).exports;
+assertEq(Object.isFrozen(exp), true);
diff --git a/js/src/jit-test/tests/wasm/bce-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/bce-x64-ion-codegen.js
new file mode 100644
index 0000000000..6a57d1dd8b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bce-x64-ion-codegen.js
@@ -0,0 +1,68 @@
+// |jit-test| --wasm-compiler=optimizing; --disable-wasm-huge-memory; --spectre-mitigations=off; skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || getJitCompilerOptions()["ion.check-range-analysis"]; include:codegen-x64-test.js
+
+// Spectre mitigation is disabled above to make the generated code simpler to
+// match; ion.check-range-analysis makes a hash of the code and makes testing
+// pointless.
+
+// White-box testing of bounds check elimination on 64-bit systems.
+//
+// This is probably fairly brittle, but BCE on 64-bit platforms regressed (bug
+// 1735207) without us noticing, so it's not like we can do without these tests.
+//
+// See also bce-x86-ion-codegen.js.
+//
+// If this turns out to be too brittle to be practical then an alternative to
+// testing the output code is to do what we do for SIMD, record (in a log or
+// buffer of some kind) that certain optimizations triggered, and then check the
+// log.
+
+var memTypes = [''];
+if (wasmMemory64Enabled()) {
+    memTypes.push('i64')
+}
+
+for ( let memType of memTypes ) {
+    let dataType = memType ? memType : 'i32';
+
+    // Make sure the check for the second load is removed: the two load
+    // instructions should appear back-to-back in the output.
+    codegenTestX64_adhoc(
+`(module
+   (memory ${memType} 1)
+   (func (export "f") (param ${dataType}) (result i32)
+     (local ${dataType})
+     (local.set 1 (${dataType}.add (local.get 0) (${dataType}.const 8)))
+     (i32.load (local.get 1))
+     drop
+     (i32.load (local.get 1))))`,
+    'f', `
+48 3b ..                  cmp %r.., %r..
+0f 83 .. 00 00 00         jnb 0x00000000000000..
+41 8b .. ..               movl \\(%r15,%r..,1\\), %e..
+41 8b .. ..               movl \\(%r15,%r..,1\\), %eax`,
+        {no_prefix:true});
+
+    // Make sure constant indices below the heap minimum do not require a bounds
+    // check.
+    codegenTestX64_adhoc(
+`(module
+   (memory ${memType} 1)
+   (func (export "f") (result i32)
+     (i32.load (${dataType}.const 16))))`,
+    'f',
+    `41 8b 47 10               movl 0x10\\(%r15\\), %eax`);
+
+    // Ditto, even at the very limit of the known heap, extending into the guard
+    // page.  This is an OOB access, of course, but it needs no explicit bounds
+    // check.
+    codegenTestX64_adhoc(
+`(module
+   (memory ${memType} 1)
+   (func (export "f") (result i32)
+     (i32.load (${dataType}.const 65535))))`,
+    'f',
+`
+b8 ff ff 00 00            mov \\$0xFFFF, %eax
+41 8b 04 07               movl \\(%r15,%rax,1\\), %eax`);
+}
+
diff --git a/js/src/jit-test/tests/wasm/bce-x86-ion-codegen.js b/js/src/jit-test/tests/wasm/bce-x86-ion-codegen.js
new file mode 100644
index 0000000000..82e8695963
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bce-x86-ion-codegen.js
@@ -0,0 +1,54 @@
+// |jit-test| --wasm-compiler=optimizing; --spectre-mitigations=off; skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x86 || getBuildConfiguration().simulator || getJitCompilerOptions()["ion.check-range-analysis"]; include:codegen-x86-test.js
+
+// Spectre mitigation is disabled above to make the generated code simpler to
+// match; ion.check-range-analysis makes a hash of the code and makes testing
+// pointless.
+
+// White-box testing of bounds check elimination on 32-bit systems.
+//
+// This is probably fairly brittle, but BCE (on 64-bit platforms) regressed (bug
+// 1735207) without us noticing, so it's not like we can do without these tests.
+//
+// See also bce-x64-ion-codegen.js.
+
+// Make sure the check for the second load is removed: the two load instructions
+// should appear back-to-back in the output.
+codegenTestX86_adhoc(
+`(module
+   (memory 1)
+   (func (export "f") (param i32) (result i32)
+     (local i32)
+     (local.set 1 (i32.add (local.get 0) (i32.const 4)))
+     (i32.load (local.get 1))
+     drop
+     (i32.load (local.get 1))))`,
+    'f', `
+3b ..                     cmp %e.., %e..
+0f 83 .. 00 00 00         jnb 0x00000000000000..
+8b .. ..                  movl \\(%r..,%r..,1\\), %e..
+8b .. ..                  movl \\(%r..,%r..,1\\), %eax`,
+    {no_prefix:true});
+
+// Make sure constant indices below the heap minimum do not require a bounds check.
+// The first movl from *rsi below loads the heap base from Tls, an x86-ism.
+codegenTestX86_adhoc(
+`(module
+   (memory 1)
+   (func (export "f") (result i32)
+     (i32.load (i32.const 16))))`,
+    'f', `
+8b ..                     movl \\(%rsi\\), %e..
+8b .. 10                  movl 0x10\\(%r..\\), %eax`);
+
+// Ditto, even at the very limit of the known heap, extending into the guard
+// page.  This is an OOB access, of course, but it needs no explicit bounds
+// check.
+codegenTestX86_adhoc(
+`(module
+   (memory 1)
+   (func (export "f") (result i32)
+     (i32.load (i32.const 65535))))`,
+    'f',
+`
+8b ..                     movl \\(%rsi\\), %e..
+8b .. ff ff 00 00         movl 0xFFFF\\(%r..\\), %eax`);
diff --git a/js/src/jit-test/tests/wasm/bce.js b/js/src/jit-test/tests/wasm/bce.js
new file mode 100644
index 0000000000..0097ad7f54
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bce.js
@@ -0,0 +1,190 @@
+mem='\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f'+
+    '\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'+
+    '\x00'.repeat(65488) +
+    '\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
+
+let accessWidth = {
+  '8_s':  1,
+  '8_u':  1,
+  '16_s': 2,
+  '16_u': 2,
+  '':     4,
+  'f32':  4,
+  'f64':  8,
+}
+
+let baseOp = {
+  '8_s':  'i32',
+  '8_u':  'i32',
+  '16_s': 'i32',
+  '16_u': 'i32',
+  '':     'i32',
+  'f32':  'f32',
+  'f64':  'f64',
+}
+
+function toSigned(width, num) {
+  let unsignedMax = Math.pow(2, accessWidth[width] * 8) - 1;
+  let signedMax = Math.pow(2, accessWidth[width] * 8 - 1) - 1;
+
+  return (num <= signedMax ? num : -(unsignedMax + 1 - num));
+}
+
+function fromLittleEndianNum(width, bytes) {
+  let base = 1;
+  var res = 0;
+  for (var i = 0; i < accessWidth[width]; i++) {
+    res += base * bytes[i];
+    base *= 256;
+  }
+  return res;
+}
+
+function getInt(width, offset, mem) {
+  var bytes = [ ];
+  for (var i = offset; i < offset + accessWidth[width]; i++) {
+    if (i < mem.length)
+      bytes.push(mem.charCodeAt(i));
+    else
+      bytes.push(0);
+  }
+
+  var res = fromLittleEndianNum(width, bytes);
+  if (width == '8_s' || width == '16_s' || width == '')
+    res = toSigned(width, res);
+  return res;
+}
+
+function loadTwiceModule(type, ext, offset, align) {
+    // TODO: Generate memory from byte string
+    return wasmEvalText(
+    `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (data (i32.const 65520) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func (param i32) (param i32) (result ${type})
+         (drop (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+         ))
+         (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 1)
+         )
+       ) (export "" (func 0)))`
+    ).exports[""];
+}
+
+function loadTwiceSameBasePlusConstModule(type, ext, offset, align, addConst) {
+    return wasmEvalText(
+    `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (data (i32.const 65520) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func (param i32) (result ${type})
+         (drop (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+         ))
+         (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (i32.add (local.get 0) (i32.const ${addConst}))
+         )
+       ) (export "" (func 0)))`
+    ).exports[""];
+}
+
+function loadTwiceSameBasePlusNonConstModule(type, ext, offset, align) {
+    return wasmEvalText(
+    `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (data (i32.const 65520) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func (param i32) (param i32) (result ${type})
+         (drop (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+         ))
+         (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (i32.add (local.get 0) (local.get 1))
+         )
+       ) (export "" (func 0)))`
+    ).exports[""];
+}
+
+/*
+ * On x64 falsely removed bounds checks will be masked by the signal handlers.
+ * Thus it is important that these tests be run on x86.
+ */
+
+function testOOB(mod, args) {
+    assertErrorMessage(() => mod(...args), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOk(mod, args, expected, expectedType) {
+    assertEq(mod(...args), expected);
+}
+
+// TODO: It would be nice to verify how many BCs are eliminated on positive tests.
+
+const align = 0;
+for (let offset of [0, 1, 2, 3, 4, 8, 16, 41, 0xfff8]) {
+
+  var widths = ['8_s', '8_u', '16_s', '16_u', '']
+
+  for (let width of widths) {
+    // Accesses of 1 byte.
+    let lastValidIndex = 0x10000 - offset - accessWidth[width];
+    let op = baseOp[width];
+
+    var mod = loadTwiceModule(op, width, offset, align);
+
+    // Two consecutive loads from two different bases
+    testOk(mod, [lastValidIndex, lastValidIndex], getInt(width, lastValidIndex + offset, mem), op);
+    testOOB(mod, [lastValidIndex + 42, lastValidIndex + 42]);
+    testOOB(mod, [lastValidIndex, lastValidIndex + 42]);
+
+    mod = loadTwiceSameBasePlusConstModule(op, width, offset, align, 1);
+
+    testOk(mod, [lastValidIndex-1], getInt(width, lastValidIndex + offset, mem), op);
+    testOOB(mod, [lastValidIndex]);
+
+    // Two consecutive loads from same base with different offsets
+    mod = loadTwiceSameBasePlusConstModule(op, width, offset, align, 2);
+
+    testOk(mod, [lastValidIndex-2], getInt(width, lastValidIndex + offset, mem), op);
+    testOOB(mod, [lastValidIndex-1, 2]);
+
+    mod = loadTwiceSameBasePlusConstModule(op, width, offset, align, lastValidIndex);
+
+    testOk(mod, [0], getInt(width, lastValidIndex + offset, mem), op);
+    testOOB(mod, [1]);
+
+    mod = loadTwiceSameBasePlusNonConstModule(op, width, offset, align);
+    testOk(mod, [0, 1], getInt(width, 1 + offset, mem), op);
+    testOk(mod, [0, lastValidIndex], getInt(width, lastValidIndex + offset, mem), op);
+    testOOB(mod, [1, lastValidIndex])
+
+    // TODO: All of the above with mixed loads and stores
+
+    // TODO: Branching - what do we want?
+
+    // TODO: Just loops
+    //         - loop invariant checks
+    //         - loop dependant checks remaining inbounds
+    //         - loop dependant checks going out-of bounds.
+    //
+    // TODO: Loops + branching
+    //         - loop invariant checks guarded by a loop invariant branch?
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/bench/README.txt b/js/src/jit-test/tests/wasm/bench/README.txt
new file mode 100644
index 0000000000..4f51731541
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bench/README.txt
@@ -0,0 +1,12 @@
+These programs come from the embenchen benchmark suite.  The source
+code and Makefiles from which they were built can be found in
+https://github.com/lars-t-hansen/embenchen/, in the src directory.
+
+Invariably, the Makefiles were set up with -DJITTEST (see comments in
+those files), to configure the programs with very small input problems
+that will run to completion in many configurations even on slower
+systems.
+
+(Should that repo not be available, it should be possible to piece
+together sources from https://github.com/kripken/embenchen and
+https://github.com/kripken/emscripten/.)
diff --git a/js/src/jit-test/tests/wasm/bench/directives.txt b/js/src/jit-test/tests/wasm/bench/directives.txt
new file mode 100644
index 0000000000..8bb976be49
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bench/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/bench/wasm_box2d.js b/js/src/jit-test/tests/wasm/bench/wasm_box2d.js
new file mode 100644
index 0000000000..a574424be5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bench/wasm_box2d.js
@@ -0,0 +1,3070 @@
+const build = getBuildConfiguration();
+const isSimulator = build['arm-simulator'] ||
+                    build['arm64-simulator'] ||
+                    build['mips32-simulator'] ||
+                    build['mips64-simulator'];
+
+// This test often times out on debug simulators due to the extreme slowdown.
+if (build['debug'] && isSimulator)
+  quit();
+
+// All the glue code is wrapped in a function so it can be executed uncached and
+// cached or compiled separately.
+function runBox2d(cacheEntryOrModule) {
+
+// The Module object: Our interface to the outside world. We import
+// and export values on it, and do the work to get that through
+// closure compiler if necessary. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to do an eval in order to handle the closure compiler
+// case, where this code here is minified but Module was defined
+// elsewhere (e.g. case 4 above). We also need to check if Module
+// already exists (e.g. case 3 above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define   var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module;
+if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {};
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = {};
+for (var key in Module) {
+  if (Module.hasOwnProperty(key)) {
+    moduleOverrides[key] = Module[key];
+  }
+}
+
+if (!Module['print']) Module['print'] = print;
+if (typeof printErr != 'undefined') Module['printErr'] = print;
+
+if (typeof read != 'undefined') {
+Module['read'] = read;
+} else {
+Module['read'] = function read() { throw 'no read() available' };
+}
+
+if (typeof scriptArgs != 'undefined') {
+Module['arguments'] = scriptArgs;
+} else if (typeof arguments != 'undefined') {
+Module['arguments'] = arguments;
+}
+
+
+function globalEval(x) {
+  eval.call(null, x);
+}
+if (!Module['load'] && Module['read']) {
+  Module['load'] = function load(f) {
+    globalEval(Module['read'](f));
+  };
+}
+if (!Module['print']) {
+  Module['print'] = function(){};
+}
+if (!Module['printErr']) {
+  Module['printErr'] = Module['print'];
+}
+if (!Module['arguments']) {
+  Module['arguments'] = [];
+}
+if (!Module['thisProgram']) {
+  Module['thisProgram'] = './this.program';
+}
+
+// *** Environment setup code ***
+
+// Closure helpers
+Module.print = Module['print'];
+Module.printErr = Module['printErr'];
+
+// Callbacks
+Module['preRun'] = [];
+Module['postRun'] = [];
+
+// Merge back in the overrides
+for (var key in moduleOverrides) {
+  if (moduleOverrides.hasOwnProperty(key)) {
+    Module[key] = moduleOverrides[key];
+  }
+}
+// Free the object hierarchy contained in the overrides, this lets the GC
+// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.
+moduleOverrides = undefined;
+
+
+
+// {{PREAMBLE_ADDITIONS}}
+
+// === Preamble library stuff ===
+
+// Documentation for the public APIs defined in this file must be updated in:
+//    site/source/docs/api_reference/preamble.js.rst
+// A prebuilt local version of the documentation is available at:
+//    site/build/text/docs/api_reference/preamble.js.txt
+// You can also build docs locally as HTML or other formats in site/
+// An online HTML version (which may be of a different version of Emscripten)
+//    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
+
+//========================================
+// Runtime code shared with compiler
+//========================================
+
+var Runtime = {
+  setTempRet0: function (value) {
+    tempRet0 = value;
+  },
+  getTempRet0: function () {
+    return tempRet0;
+  },
+  stackSave: function () {
+    return STACKTOP;
+  },
+  stackRestore: function (stackTop) {
+    STACKTOP = stackTop;
+  },
+  getNativeTypeSize: function (type) {
+    switch (type) {
+      case 'i1': case 'i8': return 1;
+      case 'i16': return 2;
+      case 'i32': return 4;
+      case 'i64': return 8;
+      case 'float': return 4;
+      case 'double': return 8;
+      default: {
+        if (type[type.length-1] === '*') {
+          return Runtime.QUANTUM_SIZE; // A pointer
+        } else if (type[0] === 'i') {
+          var bits = parseInt(type.substr(1));
+          assert(bits % 8 === 0);
+          return bits/8;
+        } else {
+          return 0;
+        }
+      }
+    }
+  },
+  getNativeFieldSize: function (type) {
+    return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
+  },
+  STACK_ALIGN: 16,
+  prepVararg: function (ptr, type) {
+    if (type === 'double' || type === 'i64') {
+      // move so the load is aligned
+      if (ptr & 7) {
+        assert((ptr & 7) === 4);
+        ptr += 4;
+      }
+    } else {
+      assert((ptr & 3) === 0);
+    }
+    return ptr;
+  },
+  getAlignSize: function (type, size, vararg) {
+    // we align i64s and doubles on 64-bit boundaries, unlike x86
+    if (!vararg && (type == 'i64' || type == 'double')) return 8;
+    if (!type) return Math.min(size, 8); // align structures internally to 64 bits
+    return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE);
+  },
+  dynCall: function (sig, ptr, args) {
+    if (args && args.length) {
+      return Module['dynCall_' + sig].apply(null, [ptr].concat(args));
+    } else {
+      return Module['dynCall_' + sig].call(null, ptr);
+    }
+  },
+  functionPointers: [],
+  addFunction: function (func) {
+    for (var i = 0; i < Runtime.functionPointers.length; i++) {
+      if (!Runtime.functionPointers[i]) {
+        Runtime.functionPointers[i] = func;
+        return 2*(1 + i);
+      }
+    }
+    throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.';
+  },
+  removeFunction: function (index) {
+    Runtime.functionPointers[(index-2)/2] = null;
+  },
+  warnOnce: function (text) {
+    if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
+    if (!Runtime.warnOnce.shown[text]) {
+      Runtime.warnOnce.shown[text] = 1;
+      Module.printErr(text);
+    }
+  },
+  funcWrappers: {},
+  getFuncWrapper: function (func, sig) {
+    assert(sig);
+    if (!Runtime.funcWrappers[sig]) {
+      Runtime.funcWrappers[sig] = {};
+    }
+    var sigCache = Runtime.funcWrappers[sig];
+    if (!sigCache[func]) {
+      // optimize away arguments usage in common cases
+      if (sig.length === 1) {
+        sigCache[func] = function dynCall_wrapper() {
+          return Runtime.dynCall(sig, func);
+        };
+      } else if (sig.length === 2) {
+        sigCache[func] = function dynCall_wrapper(arg) {
+          return Runtime.dynCall(sig, func, [arg]);
+        };
+      } else {
+        // general case
+        sigCache[func] = function dynCall_wrapper() {
+          return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments));
+        };
+      }
+    }
+    return sigCache[func];
+  },
+  getCompilerSetting: function (name) {
+    throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work';
+  },
+  stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+15)&-16); return ret; },
+  staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+15)&-16); return ret; },
+  dynamicAlloc: function (size) { var ret = HEAP32[DYNAMICTOP_PTR>>2];var end = (((ret + size + 15)|0) & -16);HEAP32[DYNAMICTOP_PTR>>2] = end;if (end >= TOTAL_MEMORY) {var success = enlargeMemory();if (!success) {HEAP32[DYNAMICTOP_PTR>>2] = ret;return 0;}}return ret;},
+  alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 16))*(quantum ? quantum : 16); return ret; },
+  makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0))); return ret; },
+  GLOBAL_BASE: 1024,
+  QUANTUM_SIZE: 4,
+  __dummy__: 0
+}
+
+
+
+Module["Runtime"] = Runtime;
+
+
+
+//========================================
+// Runtime essentials
+//========================================
+
+var ABORT = 0; // whether we are quitting the application. no code should run after this. set in exit() and abort()
+var EXITSTATUS = 0;
+
+function assert(condition, text) {
+  if (!condition) {
+    abort('Assertion failed: ' + text);
+  }
+}
+
+var globalScope = this;
+
+// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
+function getCFunc(ident) {
+  var func = Module['_' + ident]; // closure exported function
+  if (!func) {
+    try { func = eval('_' + ident); } catch(e) {}
+  }
+  assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
+  return func;
+}
+
+var cwrap, ccall;
+(function(){
+  var JSfuncs = {
+    // Helpers for cwrap -- it can't refer to Runtime directly because it might
+    // be renamed by closure, instead it calls JSfuncs['stackSave'].body to find
+    // out what the minified function name is.
+    'stackSave': function() {
+      Runtime.stackSave()
+    },
+    'stackRestore': function() {
+      Runtime.stackRestore()
+    },
+    // type conversion from js to c
+    'arrayToC' : function(arr) {
+      var ret = Runtime.stackAlloc(arr.length);
+      writeArrayToMemory(arr, ret);
+      return ret;
+    },
+    'stringToC' : function(str) {
+      var ret = 0;
+      if (str !== null && str !== undefined && str !== 0) { // null string
+        // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0'
+        var len = (str.length << 2) + 1;
+        ret = Runtime.stackAlloc(len);
+        stringToUTF8(str, ret, len);
+      }
+      return ret;
+    }
+  };
+  // For fast lookup of conversion functions
+  var toC = {'string' : JSfuncs['stringToC'], 'array' : JSfuncs['arrayToC']};
+
+  // C calling interface.
+  ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
+    var func = getCFunc(ident);
+    var cArgs = [];
+    var stack = 0;
+    if (args) {
+      for (var i = 0; i < args.length; i++) {
+        var converter = toC[argTypes[i]];
+        if (converter) {
+          if (stack === 0) stack = Runtime.stackSave();
+          cArgs[i] = converter(args[i]);
+        } else {
+          cArgs[i] = args[i];
+        }
+      }
+    }
+    var ret = func.apply(null, cArgs);
+    if (returnType === 'string') ret = Pointer_stringify(ret);
+    if (stack !== 0) {
+      if (opts && opts.async) {
+        EmterpreterAsync.asyncFinalizers.push(function() {
+          Runtime.stackRestore(stack);
+        });
+        return;
+      }
+      Runtime.stackRestore(stack);
+    }
+    return ret;
+  }
+
+  var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/;
+  function parseJSFunc(jsfunc) {
+    // Match the body and the return value of a javascript function source
+    var parsed = jsfunc.toString().match(sourceRegex).slice(1);
+    return {arguments : parsed[0], body : parsed[1], returnValue: parsed[2]}
+  }
+
+  // sources of useful functions. we create this lazily as it can trigger a source decompression on this entire file
+  var JSsource = null;
+  function ensureJSsource() {
+    if (!JSsource) {
+      JSsource = {};
+      for (var fun in JSfuncs) {
+        if (JSfuncs.hasOwnProperty(fun)) {
+          // Elements of toCsource are arrays of three items:
+          // the code, and the return value
+          JSsource[fun] = parseJSFunc(JSfuncs[fun]);
+        }
+      }
+    }
+  }
+
+  cwrap = function cwrap(ident, returnType, argTypes) {
+    argTypes = argTypes || [];
+    var cfunc = getCFunc(ident);
+    // When the function takes numbers and returns a number, we can just return
+    // the original function
+    var numericArgs = argTypes.every(function(type){ return type === 'number'});
+    var numericRet = (returnType !== 'string');
+    if ( numericRet && numericArgs) {
+      return cfunc;
+    }
+    // Creation of the arguments list (["$1","$2",...,"$nargs"])
+    var argNames = argTypes.map(function(x,i){return '$'+i});
+    var funcstr = "(function(" + argNames.join(',') + ") {";
+    var nargs = argTypes.length;
+    if (!numericArgs) {
+      // Generate the code needed to convert the arguments from javascript
+      // values to pointers
+      ensureJSsource();
+      funcstr += 'var stack = ' + JSsource['stackSave'].body + ';';
+      for (var i = 0; i < nargs; i++) {
+        var arg = argNames[i], type = argTypes[i];
+        if (type === 'number') continue;
+        var convertCode = JSsource[type + 'ToC']; // [code, return]
+        funcstr += 'var ' + convertCode.arguments + ' = ' + arg + ';';
+        funcstr += convertCode.body + ';';
+        funcstr += arg + '=(' + convertCode.returnValue + ');';
+      }
+    }
+
+    // When the code is compressed, the name of cfunc is not literally 'cfunc' anymore
+    var cfuncname = parseJSFunc(function(){return cfunc}).returnValue;
+    // Call the function
+    funcstr += 'var ret = ' + cfuncname + '(' + argNames.join(',') + ');';
+    if (!numericRet) { // Return type can only by 'string' or 'number'
+      // Convert the result to a string
+      var strgfy = parseJSFunc(function(){return Pointer_stringify}).returnValue;
+      funcstr += 'ret = ' + strgfy + '(ret);';
+    }
+    if (!numericArgs) {
+      // If we had a stack, restore it
+      ensureJSsource();
+      funcstr += JSsource['stackRestore'].body.replace('()', '(stack)') + ';';
+    }
+    funcstr += 'return ret})';
+    return eval(funcstr);
+  };
+})();
+Module["ccall"] = ccall;
+Module["cwrap"] = cwrap;
+
+function setValue(ptr, value, type, noSafe) {
+  type = type || 'i8';
+  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+    switch(type) {
+      case 'i1': HEAP8[((ptr)>>0)]=value; break;
+      case 'i8': HEAP8[((ptr)>>0)]=value; break;
+      case 'i16': HEAP16[((ptr)>>1)]=value; break;
+      case 'i32': HEAP32[((ptr)>>2)]=value; break;
+      case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
+      case 'float': HEAPF32[((ptr)>>2)]=value; break;
+      case 'double': HEAPF64[((ptr)>>3)]=value; break;
+      default: abort('invalid type for setValue: ' + type);
+    }
+}
+Module["setValue"] = setValue;
+
+
+function getValue(ptr, type, noSafe) {
+  type = type || 'i8';
+  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
+    switch(type) {
+      case 'i1': return HEAP8[((ptr)>>0)];
+      case 'i8': return HEAP8[((ptr)>>0)];
+      case 'i16': return HEAP16[((ptr)>>1)];
+      case 'i32': return HEAP32[((ptr)>>2)];
+      case 'i64': return HEAP32[((ptr)>>2)];
+      case 'float': return HEAPF32[((ptr)>>2)];
+      case 'double': return HEAPF64[((ptr)>>3)];
+      default: abort('invalid type for setValue: ' + type);
+    }
+  return null;
+}
+Module["getValue"] = getValue;
+
+var ALLOC_NORMAL = 0; // Tries to use _malloc()
+var ALLOC_STACK = 1; // Lives for the duration of the current function call
+var ALLOC_STATIC = 2; // Cannot be freed
+var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk
+var ALLOC_NONE = 4; // Do not allocate
+Module["ALLOC_NORMAL"] = ALLOC_NORMAL;
+Module["ALLOC_STACK"] = ALLOC_STACK;
+Module["ALLOC_STATIC"] = ALLOC_STATIC;
+Module["ALLOC_DYNAMIC"] = ALLOC_DYNAMIC;
+Module["ALLOC_NONE"] = ALLOC_NONE;
+
+// allocate(): This is for internal use. You can use it yourself as well, but the interface
+//             is a little tricky (see docs right below). The reason is that it is optimized
+//             for multiple syntaxes to save space in generated code. So you should
+//             normally not use allocate(), and instead allocate memory using _malloc(),
+//             initialize it with setValue(), and so forth.
+// @slab: An array of data, or a number. If a number, then the size of the block to allocate,
+//        in *bytes* (note that this is sometimes confusing: the next parameter does not
+//        affect this!)
+// @types: Either an array of types, one for each byte (or 0 if no type at that position),
+//         or a single type which is used for the entire block. This only matters if there
+//         is initial data - if @slab is a number, then this does not matter at all and is
+//         ignored.
+// @allocator: How to allocate memory, see ALLOC_*
+function allocate(slab, types, allocator, ptr) {
+  var zeroinit, size;
+  if (typeof slab === 'number') {
+    zeroinit = true;
+    size = slab;
+  } else {
+    zeroinit = false;
+    size = slab.length;
+  }
+
+  var singleType = typeof types === 'string' ? types : null;
+
+  var ret;
+  if (allocator == ALLOC_NONE) {
+    ret = ptr;
+  } else {
+    ret = [typeof _malloc === 'function' ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
+  }
+
+  if (zeroinit) {
+    var ptr = ret, stop;
+    assert((ret & 3) == 0);
+    stop = ret + (size & ~3);
+    for (; ptr < stop; ptr += 4) {
+      HEAP32[((ptr)>>2)]=0;
+    }
+    stop = ret + size;
+    while (ptr < stop) {
+      HEAP8[((ptr++)>>0)]=0;
+    }
+    return ret;
+  }
+
+  if (singleType === 'i8') {
+    if (slab.subarray || slab.slice) {
+      HEAPU8.set(slab, ret);
+    } else {
+      HEAPU8.set(new Uint8Array(slab), ret);
+    }
+    return ret;
+  }
+
+  var i = 0, type, typeSize, previousType;
+  while (i < size) {
+    var curr = slab[i];
+
+    if (typeof curr === 'function') {
+      curr = Runtime.getFunctionIndex(curr);
+    }
+
+    type = singleType || types[i];
+    if (type === 0) {
+      i++;
+      continue;
+    }
+
+    if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later
+
+    setValue(ret+i, curr, type);
+
+    // no need to look up size unless type changes, so cache it
+    if (previousType !== type) {
+      typeSize = Runtime.getNativeTypeSize(type);
+      previousType = type;
+    }
+    i += typeSize;
+  }
+
+  return ret;
+}
+Module["allocate"] = allocate;
+
+// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready
+function getMemory(size) {
+  if (!staticSealed) return Runtime.staticAlloc(size);
+  if (!runtimeInitialized) return Runtime.dynamicAlloc(size);
+  return _malloc(size);
+}
+Module["getMemory"] = getMemory;
+
+function Pointer_stringify(ptr, /* optional */ length) {
+  if (length === 0 || !ptr) return '';
+  // TODO: use TextDecoder
+  // Find the length, and check for UTF while doing so
+  var hasUtf = 0;
+  var t;
+  var i = 0;
+  while (1) {
+    t = HEAPU8[(((ptr)+(i))>>0)];
+    hasUtf |= t;
+    if (t == 0 && !length) break;
+    i++;
+    if (length && i == length) break;
+  }
+  if (!length) length = i;
+
+  var ret = '';
+
+  if (hasUtf < 128) {
+    var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack
+    var curr;
+    while (length > 0) {
+      curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)));
+      ret = ret ? ret + curr : curr;
+      ptr += MAX_CHUNK;
+      length -= MAX_CHUNK;
+    }
+    return ret;
+  }
+  return Module['UTF8ToString'](ptr);
+}
+Module["Pointer_stringify"] = Pointer_stringify;
+
+// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+
+function AsciiToString(ptr) {
+  var str = '';
+  while (1) {
+    var ch = HEAP8[((ptr++)>>0)];
+    if (!ch) return str;
+    str += String.fromCharCode(ch);
+  }
+}
+Module["AsciiToString"] = AsciiToString;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP.
+
+function stringToAscii(str, outPtr) {
+  return writeAsciiToMemory(str, outPtr, false);
+}
+Module["stringToAscii"] = stringToAscii;
+
+// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns
+// a copy of that string as a Javascript String object.
+
+var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined;
+function UTF8ArrayToString(u8Array, idx) {
+  var endPtr = idx;
+  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
+  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
+  while (u8Array[endPtr]) ++endPtr;
+
+  if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
+    return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
+  } else {
+    var u0, u1, u2, u3, u4, u5;
+
+    var str = '';
+    while (1) {
+      // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
+      u0 = u8Array[idx++];
+      if (!u0) return str;
+      if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }
+      u1 = u8Array[idx++] & 63;
+      if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }
+      u2 = u8Array[idx++] & 63;
+      if ((u0 & 0xF0) == 0xE0) {
+        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+      } else {
+        u3 = u8Array[idx++] & 63;
+        if ((u0 & 0xF8) == 0xF0) {
+          u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3;
+        } else {
+          u4 = u8Array[idx++] & 63;
+          if ((u0 & 0xFC) == 0xF8) {
+            u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4;
+          } else {
+            u5 = u8Array[idx++] & 63;
+            u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5;
+          }
+        }
+      }
+      if (u0 < 0x10000) {
+        str += String.fromCharCode(u0);
+      } else {
+        var ch = u0 - 0x10000;
+        str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+      }
+    }
+  }
+}
+Module["UTF8ArrayToString"] = UTF8ArrayToString;
+
+// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+
+function UTF8ToString(ptr) {
+  return UTF8ArrayToString(HEAPU8,ptr);
+}
+Module["UTF8ToString"] = UTF8ToString;
+
+// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx',
+// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP.
+// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
+// Parameters:
+//   str: the Javascript string to copy.
+//   outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element.
+//   outIdx: The starting offset in the array to begin the copying.
+//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
+//                    terminator, i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else.
+//                    maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator.
+// Returns the number of bytes written, EXCLUDING the null terminator.
+
+function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
+  if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes.
+    return 0;
+
+  var startIdx = outIdx;
+  var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
+  for (var i = 0; i < str.length; ++i) {
+    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
+    // See http://unicode.org/faq/utf_bom.html#utf16-3
+    // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629
+    var u = str.charCodeAt(i); // possibly a lead surrogate
+    if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
+    if (u <= 0x7F) {
+      if (outIdx >= endIdx) break;
+      outU8Array[outIdx++] = u;
+    } else if (u <= 0x7FF) {
+      if (outIdx + 1 >= endIdx) break;
+      outU8Array[outIdx++] = 0xC0 | (u >> 6);
+      outU8Array[outIdx++] = 0x80 | (u & 63);
+    } else if (u <= 0xFFFF) {
+      if (outIdx + 2 >= endIdx) break;
+      outU8Array[outIdx++] = 0xE0 | (u >> 12);
+      outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
+      outU8Array[outIdx++] = 0x80 | (u & 63);
+    } else if (u <= 0x1FFFFF) {
+      if (outIdx + 3 >= endIdx) break;
+      outU8Array[outIdx++] = 0xF0 | (u >> 18);
+      outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
+      outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
+      outU8Array[outIdx++] = 0x80 | (u & 63);
+    } else if (u <= 0x3FFFFFF) {
+      if (outIdx + 4 >= endIdx) break;
+      outU8Array[outIdx++] = 0xF8 | (u >> 24);
+      outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63);
+      outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
+      outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
+      outU8Array[outIdx++] = 0x80 | (u & 63);
+    } else {
+      if (outIdx + 5 >= endIdx) break;
+      outU8Array[outIdx++] = 0xFC | (u >> 30);
+      outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63);
+      outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63);
+      outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63);
+      outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63);
+      outU8Array[outIdx++] = 0x80 | (u & 63);
+    }
+  }
+  // Null-terminate the pointer to the buffer.
+  outU8Array[outIdx] = 0;
+  return outIdx - startIdx;
+}
+Module["stringToUTF8Array"] = stringToUTF8Array;
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP.
+// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write.
+// Returns the number of bytes written, EXCLUDING the null terminator.
+
+function stringToUTF8(str, outPtr, maxBytesToWrite) {
+  return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);
+}
+Module["stringToUTF8"] = stringToUTF8;
+
+// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte.
+
+function lengthBytesUTF8(str) {
+  var len = 0;
+  for (var i = 0; i < str.length; ++i) {
+    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8.
+    // See http://unicode.org/faq/utf_bom.html#utf16-3
+    var u = str.charCodeAt(i); // possibly a lead surrogate
+    if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF);
+    if (u <= 0x7F) {
+      ++len;
+    } else if (u <= 0x7FF) {
+      len += 2;
+    } else if (u <= 0xFFFF) {
+      len += 3;
+    } else if (u <= 0x1FFFFF) {
+      len += 4;
+    } else if (u <= 0x3FFFFFF) {
+      len += 5;
+    } else {
+      len += 6;
+    }
+  }
+  return len;
+}
+Module["lengthBytesUTF8"] = lengthBytesUTF8;
+
+// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns
+// a copy of that string as a Javascript String object.
+
+var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined;
+function UTF16ToString(ptr) {
+  var endPtr = ptr;
+  // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself.
+  // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage.
+  var idx = endPtr >> 1;
+  while (HEAP16[idx]) ++idx;
+  endPtr = idx << 1;
+
+  if (endPtr - ptr > 32 && UTF16Decoder) {
+    return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+  } else {
+    var i = 0;
+
+    var str = '';
+    while (1) {
+      var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
+      if (codeUnit == 0) return str;
+      ++i;
+      // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through.
+      str += String.fromCharCode(codeUnit);
+    }
+  }
+}
+
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP.
+// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write.
+// Parameters:
+//   str: the Javascript string to copy.
+//   outPtr: Byte address in Emscripten HEAP where to write the string to.
+//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
+//                    terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else.
+//                    maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator.
+// Returns the number of bytes written, EXCLUDING the null terminator.
+
+function stringToUTF16(str, outPtr, maxBytesToWrite) {
+  // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
+  if (maxBytesToWrite === undefined) {
+    maxBytesToWrite = 0x7FFFFFFF;
+  }
+  if (maxBytesToWrite < 2) return 0;
+  maxBytesToWrite -= 2; // Null terminator.
+  var startPtr = outPtr;
+  var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length;
+  for (var i = 0; i < numCharsToWrite; ++i) {
+    // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+    var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+    HEAP16[((outPtr)>>1)]=codeUnit;
+    outPtr += 2;
+  }
+  // Null-terminate the pointer to the HEAP.
+  HEAP16[((outPtr)>>1)]=0;
+  return outPtr - startPtr;
+}
+
+
+// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
+
+function lengthBytesUTF16(str) {
+  return str.length*2;
+}
+
+
+function UTF32ToString(ptr) {
+  var i = 0;
+
+  var str = '';
+  while (1) {
+    var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
+    if (utf32 == 0)
+      return str;
+    ++i;
+    // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing.
+    // See http://unicode.org/faq/utf_bom.html#utf16-3
+    if (utf32 >= 0x10000) {
+      var ch = utf32 - 0x10000;
+      str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
+    } else {
+      str += String.fromCharCode(utf32);
+    }
+  }
+}
+
+
+// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr',
+// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP.
+// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write.
+// Parameters:
+//   str: the Javascript string to copy.
+//   outPtr: Byte address in Emscripten HEAP where to write the string to.
+//   maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null
+//                    terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else.
+//                    maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator.
+// Returns the number of bytes written, EXCLUDING the null terminator.
+
+function stringToUTF32(str, outPtr, maxBytesToWrite) {
+  // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
+  if (maxBytesToWrite === undefined) {
+    maxBytesToWrite = 0x7FFFFFFF;
+  }
+  if (maxBytesToWrite < 4) return 0;
+  var startPtr = outPtr;
+  var endPtr = startPtr + maxBytesToWrite - 4;
+  for (var i = 0; i < str.length; ++i) {
+    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+    // See http://unicode.org/faq/utf_bom.html#utf16-3
+    var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+    if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
+      var trailSurrogate = str.charCodeAt(++i);
+      codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
+    }
+    HEAP32[((outPtr)>>2)]=codeUnit;
+    outPtr += 4;
+    if (outPtr + 4 > endPtr) break;
+  }
+  // Null-terminate the pointer to the HEAP.
+  HEAP32[((outPtr)>>2)]=0;
+  return outPtr - startPtr;
+}
+
+
+// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte.
+
+function lengthBytesUTF32(str) {
+  var len = 0;
+  for (var i = 0; i < str.length; ++i) {
+    // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap.
+    // See http://unicode.org/faq/utf_bom.html#utf16-3
+    var codeUnit = str.charCodeAt(i);
+    if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate.
+    len += 4;
+  }
+
+  return len;
+}
+
+
+function demangle(func) {
+  var __cxa_demangle_func = Module['___cxa_demangle'] || Module['__cxa_demangle'];
+  if (__cxa_demangle_func) {
+    try {
+      var s =
+        func.substr(1);
+      var len = lengthBytesUTF8(s)+1;
+      var buf = _malloc(len);
+      stringToUTF8(s, buf, len);
+      var status = _malloc(4);
+      var ret = __cxa_demangle_func(buf, 0, 0, status);
+      if (getValue(status, 'i32') === 0 && ret) {
+        return Pointer_stringify(ret);
+      }
+      // otherwise, libcxxabi failed
+    } catch(e) {
+      // ignore problems here
+    } finally {
+      if (buf) _free(buf);
+      if (status) _free(status);
+      if (ret) _free(ret);
+    }
+    // failure when using libcxxabi, don't demangle
+    return func;
+  }
+  Runtime.warnOnce('warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling');
+  return func;
+}
+
+function demangleAll(text) {
+  var regex =
+    /__Z[\w\d_]+/g;
+  return text.replace(regex,
+    function(x) {
+      var y = demangle(x);
+      return x === y ? x : (x + ' [' + y + ']');
+    });
+}
+
+function jsStackTrace() {
+  var err = new Error();
+  if (!err.stack) {
+    // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown,
+    // so try that as a special-case.
+    try {
+      throw new Error(0);
+    } catch(e) {
+      err = e;
+    }
+    if (!err.stack) {
+      return '(no stack trace available)';
+    }
+  }
+  return err.stack.toString();
+}
+
+function stackTrace() {
+  var js = jsStackTrace();
+  if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']();
+  return demangleAll(js);
+}
+Module["stackTrace"] = stackTrace;
+
+// Memory management
+
+var PAGE_SIZE = 16384;
+var WASM_PAGE_SIZE = 65536;
+var ASMJS_PAGE_SIZE = 16777216;
+var MIN_TOTAL_MEMORY = 16777216;
+
+function alignUp(x, multiple) {
+  if (x % multiple > 0) {
+    x += multiple - (x % multiple);
+  }
+  return x;
+}
+
+var HEAP;
+var buffer;
+var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+function updateGlobalBuffer(buf) {
+  Module['buffer'] = buffer = buf;
+}
+
+function updateGlobalBufferViews() {
+  Module['HEAP8'] = HEAP8 = new Int8Array(buffer);
+  Module['HEAP16'] = HEAP16 = new Int16Array(buffer);
+  Module['HEAP32'] = HEAP32 = new Int32Array(buffer);
+  Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer);
+  Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer);
+  Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer);
+  Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer);
+  Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer);
+}
+
+var STATIC_BASE, STATICTOP, staticSealed; // static area
+var STACK_BASE, STACKTOP, STACK_MAX; // stack area
+var DYNAMIC_BASE, DYNAMICTOP_PTR; // dynamic area handled by sbrk
+
+  STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0;
+  staticSealed = false;
+
+
+
+function abortOnCannotGrowMemory() {
+  abort('Cannot enlarge memory arrays. Either (1) compile with  -s TOTAL_MEMORY=X  with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which adjusts the size at runtime but prevents some optimizations, (3) set Module.TOTAL_MEMORY to a higher value before the program runs, or if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 ');
+}
+
+
+function enlargeMemory() {
+  abortOnCannotGrowMemory();
+}
+
+
+var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
+var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216;
+if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')');
+
+// Initialize the runtime's memory
+
+
+
+// Use a provided buffer, if there is one, or else allocate a new one
+if (Module['buffer']) {
+  buffer = Module['buffer'];
+} else {
+  // Use a WebAssembly memory where available
+  if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') {
+    Module['wasmMemory'] = new WebAssembly.Memory({ initial: TOTAL_MEMORY / WASM_PAGE_SIZE, maximum: TOTAL_MEMORY / WASM_PAGE_SIZE });
+    buffer = Module['wasmMemory'].buffer;
+  } else
+  {
+    buffer = new ArrayBuffer(TOTAL_MEMORY);
+  }
+}
+updateGlobalBufferViews();
+
+
+function getTotalMemory() {
+  return TOTAL_MEMORY;
+}
+
+// Endianness check (note: assumes compiler arch was little-endian)
+  HEAP32[0] = 0x63736d65; /* 'emsc' */
+HEAP16[1] = 0x6373;
+if (HEAPU8[2] !== 0x73 || HEAPU8[3] !== 0x63) throw 'Runtime error: expected the system to be little-endian!';
+
+Module['HEAP'] = HEAP;
+Module['buffer'] = buffer;
+Module['HEAP8'] = HEAP8;
+Module['HEAP16'] = HEAP16;
+Module['HEAP32'] = HEAP32;
+Module['HEAPU8'] = HEAPU8;
+Module['HEAPU16'] = HEAPU16;
+Module['HEAPU32'] = HEAPU32;
+Module['HEAPF32'] = HEAPF32;
+Module['HEAPF64'] = HEAPF64;
+
+function callRuntimeCallbacks(callbacks) {
+  while(callbacks.length > 0) {
+    var callback = callbacks.shift();
+    if (typeof callback == 'function') {
+      callback();
+      continue;
+    }
+    var func = callback.func;
+    if (typeof func === 'number') {
+      if (callback.arg === undefined) {
+        Module['dynCall_v'](func);
+      } else {
+        Module['dynCall_vi'](func, callback.arg);
+      }
+    } else {
+      func(callback.arg === undefined ? null : callback.arg);
+    }
+  }
+}
+
+var __ATPRERUN__  = []; // functions called before the runtime is initialized
+var __ATINIT__    = []; // functions called during startup
+var __ATMAIN__    = []; // functions called when main() is to be run
+var __ATEXIT__    = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the runtime has exited
+
+var runtimeInitialized = false;
+var runtimeExited = false;
+
+
+function preRun() {
+  // compatibility - merge in anything from Module['preRun'] at this time
+  if (Module['preRun']) {
+    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
+    while (Module['preRun'].length) {
+      addOnPreRun(Module['preRun'].shift());
+    }
+  }
+  callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function ensureInitRuntime() {
+  if (runtimeInitialized) return;
+  runtimeInitialized = true;
+  callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+  callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+  callRuntimeCallbacks(__ATEXIT__);
+  runtimeExited = true;
+}
+
+function postRun() {
+  // compatibility - merge in anything from Module['postRun'] at this time
+  if (Module['postRun']) {
+    if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
+    while (Module['postRun'].length) {
+      addOnPostRun(Module['postRun'].shift());
+    }
+  }
+  callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+  __ATPRERUN__.unshift(cb);
+}
+Module["addOnPreRun"] = addOnPreRun;
+
+function addOnInit(cb) {
+  __ATINIT__.unshift(cb);
+}
+Module["addOnInit"] = addOnInit;
+
+function addOnPreMain(cb) {
+  __ATMAIN__.unshift(cb);
+}
+Module["addOnPreMain"] = addOnPreMain;
+
+function addOnExit(cb) {
+  __ATEXIT__.unshift(cb);
+}
+Module["addOnExit"] = addOnExit;
+
+function addOnPostRun(cb) {
+  __ATPOSTRUN__.unshift(cb);
+}
+Module["addOnPostRun"] = addOnPostRun;
+
+// Tools
+
+
+function intArrayFromString(stringy, dontAddNull, length /* optional */) {
+  var len = length > 0 ? length : lengthBytesUTF8(stringy)+1;
+  var u8array = new Array(len);
+  var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+  if (dontAddNull) u8array.length = numBytesWritten;
+  return u8array;
+}
+Module["intArrayFromString"] = intArrayFromString;
+
+function intArrayToString(array) {
+  var ret = [];
+  for (var i = 0; i < array.length; i++) {
+    var chr = array[i];
+    if (chr > 0xFF) {
+      chr &= 0xFF;
+    }
+    ret.push(String.fromCharCode(chr));
+  }
+  return ret.join('');
+}
+Module["intArrayToString"] = intArrayToString;
+
+// Deprecated: This function should not be called because it is unsafe and does not provide
+// a maximum length limit of how many bytes it is allowed to write. Prefer calling the
+// function stringToUTF8Array() instead, which takes in a maximum length that can be used
+// to be secure from out of bounds writes.
+function writeStringToMemory(string, buffer, dontAddNull) {
+  Runtime.warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!');
+
+  var lastChar, end;
+  if (dontAddNull) {
+    // stringToUTF8Array always appends null. If we don't want to do that, remember the
+    // character that existed at the location where the null will be placed, and restore
+    // that after the write (below).
+    end = buffer + lengthBytesUTF8(string);
+    lastChar = HEAP8[end];
+  }
+  stringToUTF8(string, buffer, Infinity);
+  if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character.
+}
+Module["writeStringToMemory"] = writeStringToMemory;
+
+function writeArrayToMemory(array, buffer) {
+  HEAP8.set(array, buffer);
+}
+Module["writeArrayToMemory"] = writeArrayToMemory;
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+  for (var i = 0; i < str.length; ++i) {
+    HEAP8[((buffer++)>>0)]=str.charCodeAt(i);
+  }
+  // Null-terminate the pointer to the HEAP.
+  if (!dontAddNull) HEAP8[((buffer)>>0)]=0;
+}
+Module["writeAsciiToMemory"] = writeAsciiToMemory;
+
+function unSign(value, bits, ignore) {
+  if (value >= 0) {
+    return value;
+  }
+  return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
+                    : Math.pow(2, bits)         + value;
+}
+function reSign(value, bits, ignore) {
+  if (value <= 0) {
+    return value;
+  }
+  var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
+                        : Math.pow(2, bits-1);
+  if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
+                                                       // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
+                                                       // TODO: In i64 mode 1, resign the two parts separately and safely
+    value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
+  }
+  return value;
+}
+
+
+// check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 )
+if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
+  var ah  = a >>> 16;
+  var al = a & 0xffff;
+  var bh  = b >>> 16;
+  var bl = b & 0xffff;
+  return (al*bl + ((ah*bl + al*bh) << 16))|0;
+};
+Math.imul = Math['imul'];
+
+if (!Math['fround']) {
+  var froundBuffer = new Float32Array(1);
+  Math['fround'] = function(x) { froundBuffer[0] = x; return froundBuffer[0] };
+}
+Math.fround = Math['fround'];
+
+if (!Math['clz32']) Math['clz32'] = function(x) {
+  x = x >>> 0;
+  for (var i = 0; i < 32; i++) {
+    if (x & (1 << (31 - i))) return i;
+  }
+  return 32;
+};
+Math.clz32 = Math['clz32']
+
+if (!Math['trunc']) Math['trunc'] = function(x) {
+  return x < 0 ? Math.ceil(x) : Math.floor(x);
+};
+Math.trunc = Math['trunc'];
+
+var Math_abs = Math.abs;
+var Math_cos = Math.cos;
+var Math_sin = Math.sin;
+var Math_tan = Math.tan;
+var Math_acos = Math.acos;
+var Math_asin = Math.asin;
+var Math_atan = Math.atan;
+var Math_atan2 = Math.atan2;
+var Math_exp = Math.exp;
+var Math_log = Math.log;
+var Math_sqrt = Math.sqrt;
+var Math_ceil = Math.ceil;
+var Math_floor = Math.floor;
+var Math_pow = Math.pow;
+var Math_imul = Math.imul;
+var Math_fround = Math.fround;
+var Math_round = Math.round;
+var Math_min = Math.min;
+var Math_clz32 = Math.clz32;
+var Math_trunc = Math.trunc;
+
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+
+function getUniqueRunDependency(id) {
+  return id;
+}
+
+function addRunDependency(id) {
+  runDependencies++;
+  if (Module['monitorRunDependencies']) {
+    Module['monitorRunDependencies'](runDependencies);
+  }
+}
+Module["addRunDependency"] = addRunDependency;
+
+function removeRunDependency(id) {
+  runDependencies--;
+  if (Module['monitorRunDependencies']) {
+    Module['monitorRunDependencies'](runDependencies);
+  }
+  if (runDependencies == 0) {
+    if (runDependencyWatcher !== null) {
+      clearInterval(runDependencyWatcher);
+      runDependencyWatcher = null;
+    }
+    if (dependenciesFulfilled) {
+      var callback = dependenciesFulfilled;
+      dependenciesFulfilled = null;
+      callback(); // can add another dependenciesFulfilled
+    }
+  }
+}
+Module["removeRunDependency"] = removeRunDependency;
+
+Module["preloadedImages"] = {}; // maps url to image data
+Module["preloadedAudios"] = {}; // maps url to audio data
+
+
+
+var memoryInitializer = null;
+
+
+
+
+
+function integrateWasmJS(Module) {
+  // wasm.js has several methods for creating the compiled code module here:
+  //  * 'native-wasm' : use native WebAssembly support in the browser
+  //  * 'interpret-s-expr': load s-expression code from a .wast and interpret
+  //  * 'interpret-binary': load binary wasm and interpret
+  //  * 'interpret-asm2wasm': load asm.js code, translate to wasm, and interpret
+  //  * 'asmjs': no wasm, just load the asm.js code and use that (good for testing)
+  // The method can be set at compile time (BINARYEN_METHOD), or runtime by setting Module['wasmJSMethod'].
+  // The method can be a comma-separated list, in which case, we will try the
+  // options one by one. Some of them can fail gracefully, and then we can try
+  // the next.
+
+  // inputs
+
+  var method = Module['wasmJSMethod'] || 'native-wasm';
+  Module['wasmJSMethod'] = method;
+
+  var wasmBinaryFile = Module['wasmBinaryFile'] || scriptdir + 'wasm_box2d.wasm';
+
+  // utilities
+
+  var wasmPageSize = 64*1024;
+
+  var asm2wasmImports = { // special asm2wasm imports
+    "f64-rem": function(x, y) {
+      return x % y;
+    },
+    "f64-to-int": function(x) {
+      return x | 0;
+    },
+    "i32s-div": function(x, y) {
+      return ((x | 0) / (y | 0)) | 0;
+    },
+    "i32u-div": function(x, y) {
+      return ((x >>> 0) / (y >>> 0)) >>> 0;
+    },
+    "i32s-rem": function(x, y) {
+      return ((x | 0) % (y | 0)) | 0;
+    },
+    "i32u-rem": function(x, y) {
+      return ((x >>> 0) % (y >>> 0)) >>> 0;
+    },
+    "debugger": function() {
+      debugger;
+    },
+  };
+
+  var info = {
+    'global': null,
+    'env': null,
+    'asm2wasm': asm2wasmImports,
+    'parent': Module // Module inside wasm-js.cpp refers to wasm-js.cpp; this allows access to the outside program.
+  };
+
+  var exports = null;
+
+  function lookupImport(mod, base) {
+    var lookup = info;
+    if (mod.indexOf('.') < 0) {
+      lookup = (lookup || {})[mod];
+    } else {
+      var parts = mod.split('.');
+      lookup = (lookup || {})[parts[0]];
+      lookup = (lookup || {})[parts[1]];
+    }
+    if (base) {
+      lookup = (lookup || {})[base];
+    }
+    if (lookup === undefined) {
+      abort('bad lookupImport to (' + mod + ').' + base);
+    }
+    return lookup;
+  }
+
+  function mergeMemory(newBuffer) {
+    // The wasm instance creates its memory. But static init code might have written to
+    // buffer already, including the mem init file, and we must copy it over in a proper merge.
+    // TODO: avoid this copy, by avoiding such static init writes
+    // TODO: in shorter term, just copy up to the last static init write
+    var oldBuffer = Module['buffer'];
+    if (newBuffer.byteLength < oldBuffer.byteLength) {
+      Module['printErr']('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here');
+    }
+    var oldView = new Int8Array(oldBuffer);
+    var newView = new Int8Array(newBuffer);
+
+    // If we have a mem init file, do not trample it
+    if (!memoryInitializer) {
+      oldView.set(newView.subarray(Module['STATIC_BASE'], Module['STATIC_BASE'] + Module['STATIC_BUMP']), Module['STATIC_BASE']);
+    }
+
+    newView.set(oldView);
+    updateGlobalBuffer(newBuffer);
+    updateGlobalBufferViews();
+  }
+
+  var WasmTypes = {
+    none: 0,
+    i32: 1,
+    i64: 2,
+    f32: 3,
+    f64: 4
+  };
+
+  function fixImports(imports) {
+    if (!0) return imports;
+    var ret = {};
+    for (var i in imports) {
+      var fixed = i;
+      if (fixed[0] == '_') fixed = fixed.substr(1);
+      ret[fixed] = imports[i];
+    }
+    return ret;
+  }
+
+  // do-method functions
+
+  function doJustAsm(global, env, providedBuffer) {
+    // if no Module.asm, or it's the method handler helper (see below), then apply
+    // the asmjs
+    if (typeof Module['asm'] !== 'function' || Module['asm'] === methodHandler) {
+      if (!Module['asmPreload']) {
+        // you can load the .asm.js file before this, to avoid this sync xhr and eval
+        eval(Module['read'](asmjsCodeFile)); // set Module.asm
+      } else {
+        Module['asm'] = Module['asmPreload'];
+      }
+    }
+    if (typeof Module['asm'] !== 'function') {
+      Module['printErr']('asm evalling did not set the module properly');
+      return false;
+    }
+    return Module['asm'](global, env, providedBuffer);
+  }
+
+  function doNativeWasm(global, env, providedBuffer) {
+    if (typeof WebAssembly !== 'object') {
+      Module['printErr']('no native wasm support detected');
+      return false;
+    }
+    // prepare memory import
+    if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) {
+      Module['printErr']('no native wasm Memory in use');
+      return false;
+    }
+    env['memory'] = Module['wasmMemory'];
+    // Load the wasm module and create an instance of using native support in the JS engine.
+    info['global'] = {
+      'NaN': NaN,
+      'Infinity': Infinity
+    };
+    info['global.Math'] = global.Math;
+    info['env'] = env;
+    // handle a generated wasm instance, receiving its exports and
+    // performing other necessary setup
+    function receiveInstance(instance) {
+      exports = instance.exports;
+      if (exports.memory) mergeMemory(exports.memory);
+      Module['asm'] = exports;
+      Module["usingWasm"] = true;
+    }
+    Module['printErr']('asynchronously preparing wasm');
+    addRunDependency('wasm-instantiate'); // we can't run yet
+
+    (cacheEntryOrModule instanceof WebAssembly.Module
+     ? WebAssembly.instantiate(cacheEntryOrModule, info)
+       .then(instance => ({instance, module:cacheEntryOrModule}))
+     : wasmStreamingEnabled()
+       ? WebAssembly.instantiateStreaming(cacheEntryOrModule, info)
+       : WebAssembly.instantiate(cacheEntryOrModule.getBuffer(), info))
+    .then(function(output) {
+      if (!cacheEntryOrModule.module)
+        cacheEntryOrModule.module = output.module;
+
+      // receiveInstance() will swap in the exports (to Module.asm) so they can be called
+      receiveInstance(output.instance);
+      removeRunDependency('wasm-instantiate');
+    })
+    .catch(function(reason) {
+      Module['printErr']('failed to asynchronously prepare wasm:\n  ' + reason);
+    });
+    return {}; // no exports yet; we'll fill them in later
+  }
+
+  // We may have a preloaded value in Module.asm, save it
+  Module['asmPreload'] = Module['asm'];
+
+  // Memory growth integration code
+  Module['reallocBuffer'] = function(size) {
+    var PAGE_MULTIPLE = Module["usingWasm"] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE; // In wasm, heap size must be a multiple of 64KB. In asm.js, they need to be multiples of 16MB.
+    size = alignUp(size, PAGE_MULTIPLE); // round up to wasm page size
+    var old = Module['buffer'];
+    var oldSize = old.byteLength;
+    if (Module["usingWasm"]) {
+      try {
+        var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize); // .grow() takes a delta compared to the previous size
+        if (result !== (-1 | 0)) {
+          // success in native wasm memory growth, get the buffer from the memory
+          return Module['buffer'] = Module['wasmMemory'].buffer;
+        } else {
+          return null;
+        }
+      } catch(e) {
+        return null;
+      }
+    } else {
+      exports['__growWasmMemory']((size - oldSize) / wasmPageSize); // tiny wasm method that just does memory.grow
+      // in interpreter, we replace Module.buffer if we allocate
+      return Module['buffer'] !== old ? Module['buffer'] : null; // if it was reallocated, it changed
+    }
+  };
+
+  // Provide an "asm.js function" for the application, called to "link" the asm.js module. We instantiate
+  // the wasm module at that time, and it receives imports and provides exports and so forth, the app
+  // doesn't need to care that it is wasm or olyfilled wasm or asm.js.
+
+  Module['asm'] = function(global, env, providedBuffer) {
+    global = fixImports(global);
+    env = fixImports(env);
+
+    // import table
+    if (!env['table']) {
+      var TABLE_SIZE = Module['wasmTableSize'];
+      if (TABLE_SIZE === undefined) TABLE_SIZE = 1024; // works in binaryen interpreter at least
+      var MAX_TABLE_SIZE = Module['wasmMaxTableSize'];
+      if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') {
+        if (MAX_TABLE_SIZE !== undefined) {
+          env['table'] = new WebAssembly.Table({ initial: TABLE_SIZE, maximum: MAX_TABLE_SIZE, element: 'anyfunc' });
+        } else {
+          env['table'] = new WebAssembly.Table({ initial: TABLE_SIZE, element: 'anyfunc' });
+        }
+      } else {
+        env['table'] = new Array(TABLE_SIZE); // works in binaryen interpreter at least
+      }
+      Module['wasmTable'] = env['table'];
+    }
+
+    if (!env['memoryBase']) {
+      env['memoryBase'] = Module['STATIC_BASE']; // tell the memory segments where to place themselves
+    }
+    if (!env['tableBase']) {
+      env['tableBase'] = 0; // table starts at 0 by default, in dynamic linking this will change
+    }
+
+    return doNativeWasm(global, env, providedBuffer);
+  };
+
+  var methodHandler = Module['asm']; // note our method handler, as we may modify Module['asm'] later
+}
+
+integrateWasmJS(Module);
+
+// === Body ===
+
+var ASM_CONSTS = [];
+
+
+
+
+STATIC_BASE = 1024;
+
+STATICTOP = STATIC_BASE + 11904;
+  /* global initializers */  __ATINIT__.push();
+  
+
+memoryInitializer = Module["wasmJSMethod"].indexOf("asmjs") >= 0 || Module["wasmJSMethod"].indexOf("interpret-asm2wasm") >= 0 ? "wasm_box2d.js.mem" : null;
+
+
+
+
+var STATIC_BUMP = 11904;
+Module["STATIC_BASE"] = STATIC_BASE;
+Module["STATIC_BUMP"] = STATIC_BUMP;
+
+/* no memory initializer */
+var tempDoublePtr = STATICTOP; STATICTOP += 16;
+
+function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much
+
+  HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+  HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+  HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+  HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+}
+
+function copyTempDouble(ptr) {
+
+  HEAP8[tempDoublePtr] = HEAP8[ptr];
+
+  HEAP8[tempDoublePtr+1] = HEAP8[ptr+1];
+
+  HEAP8[tempDoublePtr+2] = HEAP8[ptr+2];
+
+  HEAP8[tempDoublePtr+3] = HEAP8[ptr+3];
+
+  HEAP8[tempDoublePtr+4] = HEAP8[ptr+4];
+
+  HEAP8[tempDoublePtr+5] = HEAP8[ptr+5];
+
+  HEAP8[tempDoublePtr+6] = HEAP8[ptr+6];
+
+  HEAP8[tempDoublePtr+7] = HEAP8[ptr+7];
+
+}
+
+// {{PRE_LIBRARY}}
+
+
+  function ___cxa_pure_virtual() {
+      ABORT = true;
+      throw 'Pure virtual function called!';
+    }
+
+  function ___assert_fail(condition, filename, line, func) {
+      ABORT = true;
+      throw 'Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function'] + ' at ' + stackTrace();
+    }
+
+  
+  
+  var Browser={mainLoop:{scheduler:null,method:"",currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],pause:function () {
+          Browser.mainLoop.scheduler = null;
+          Browser.mainLoop.currentlyRunningMainloop++; // Incrementing this signals the previous main loop that it's now become old, and it must return.
+        },resume:function () {
+          Browser.mainLoop.currentlyRunningMainloop++;
+          var timingMode = Browser.mainLoop.timingMode;
+          var timingValue = Browser.mainLoop.timingValue;
+          var func = Browser.mainLoop.func;
+          Browser.mainLoop.func = null;
+          _emscripten_set_main_loop(func, 0, false, Browser.mainLoop.arg, true /* do not set timing and call scheduler, we will do it on the next lines */);
+          _emscripten_set_main_loop_timing(timingMode, timingValue);
+          Browser.mainLoop.scheduler();
+        },updateStatus:function () {
+          if (Module['setStatus']) {
+            var message = Module['statusMessage'] || 'Please wait...';
+            var remaining = Browser.mainLoop.remainingBlockers;
+            var expected = Browser.mainLoop.expectedBlockers;
+            if (remaining) {
+              if (remaining < expected) {
+                Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+              } else {
+                Module['setStatus'](message);
+              }
+            } else {
+              Module['setStatus']('');
+            }
+          }
+        },runIter:function (func) {
+          if (ABORT) return;
+          if (Module['preMainLoop']) {
+            var preRet = Module['preMainLoop']();
+            if (preRet === false) {
+              return; // |return false| skips a frame
+            }
+          }
+          try {
+            func();
+          } catch (e) {
+            if (e instanceof ExitStatus) {
+              return;
+            } else {
+              if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+              throw e;
+            }
+          }
+          if (Module['postMainLoop']) Module['postMainLoop']();
+        }},isFullscreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () {
+        if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+  
+        if (Browser.initted) return;
+        Browser.initted = true;
+  
+        try {
+          new Blob();
+          Browser.hasBlobConstructor = true;
+        } catch(e) {
+          Browser.hasBlobConstructor = false;
+          console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+        }
+        Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+        Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+        if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+          console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+          Module.noImageDecoding = true;
+        }
+  
+        // Support for plugins that can process preloaded files. You can add more of these to
+        // your app by creating and appending to Module.preloadPlugins.
+        //
+        // Each plugin is asked if it can handle a file based on the file's name. If it can,
+        // it is given the file's raw data. When it is done, it calls a callback with the file's
+        // (possibly modified) data. For example, a plugin might decompress a file, or it
+        // might create some side data structure for use later (like an Image element, etc.).
+  
+        var imagePlugin = {};
+        imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+          return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+        };
+        imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+          var b = null;
+          if (Browser.hasBlobConstructor) {
+            try {
+              b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+              if (b.size !== byteArray.length) { // Safari bug #118630
+                // Safari's Blob can only take an ArrayBuffer
+                b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.getMimetype(name) });
+              }
+            } catch(e) {
+              Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+            }
+          }
+          if (!b) {
+            var bb = new Browser.BlobBuilder();
+            bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+            b = bb.getBlob();
+          }
+          var url = Browser.URLObject.createObjectURL(b);
+          var img = new Image();
+          img.onload = function img_onload() {
+            assert(img.complete, 'Image ' + name + ' could not be decoded');
+            var canvas = document.createElement('canvas');
+            canvas.width = img.width;
+            canvas.height = img.height;
+            var ctx = canvas.getContext('2d');
+            ctx.drawImage(img, 0, 0);
+            Module["preloadedImages"][name] = canvas;
+            Browser.URLObject.revokeObjectURL(url);
+            if (onload) onload(byteArray);
+          };
+          img.onerror = function img_onerror(event) {
+            console.log('Image ' + url + ' could not be decoded');
+            if (onerror) onerror();
+          };
+          img.src = url;
+        };
+        Module['preloadPlugins'].push(imagePlugin);
+  
+        var audioPlugin = {};
+        audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+          return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 };
+        };
+        audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+          var done = false;
+          function finish(audio) {
+            if (done) return;
+            done = true;
+            Module["preloadedAudios"][name] = audio;
+            if (onload) onload(byteArray);
+          }
+          function fail() {
+            if (done) return;
+            done = true;
+            Module["preloadedAudios"][name] = new Audio(); // empty shim
+            if (onerror) onerror();
+          }
+          if (Browser.hasBlobConstructor) {
+            try {
+              var b = new Blob([byteArray], { type: Browser.getMimetype(name) });
+            } catch(e) {
+              return fail();
+            }
+            var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+            var audio = new Audio();
+            audio.addEventListener('canplaythrough', function() { finish(audio) }, false); // use addEventListener due to chromium bug 124926
+            audio.onerror = function audio_onerror(event) {
+              if (done) return;
+              console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+              function encode64(data) {
+                var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+                var PAD = '=';
+                var ret = '';
+                var leftchar = 0;
+                var leftbits = 0;
+                for (var i = 0; i < data.length; i++) {
+                  leftchar = (leftchar << 8) | data[i];
+                  leftbits += 8;
+                  while (leftbits >= 6) {
+                    var curr = (leftchar >> (leftbits-6)) & 0x3f;
+                    leftbits -= 6;
+                    ret += BASE[curr];
+                  }
+                }
+                if (leftbits == 2) {
+                  ret += BASE[(leftchar&3) << 4];
+                  ret += PAD + PAD;
+                } else if (leftbits == 4) {
+                  ret += BASE[(leftchar&0xf) << 2];
+                  ret += PAD;
+                }
+                return ret;
+              }
+              audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+              finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+            };
+            audio.src = url;
+            // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+            Browser.safeSetTimeout(function() {
+              finish(audio); // try to use it even though it is not necessarily ready to play
+            }, 10000);
+          } else {
+            return fail();
+          }
+        };
+        Module['preloadPlugins'].push(audioPlugin);
+  
+        // Canvas event setup
+  
+        function pointerLockChange() {
+          Browser.pointerLock = document['pointerLockElement'] === Module['canvas'] ||
+                                document['mozPointerLockElement'] === Module['canvas'] ||
+                                document['webkitPointerLockElement'] === Module['canvas'] ||
+                                document['msPointerLockElement'] === Module['canvas'];
+        }
+        var canvas = Module['canvas'];
+        if (canvas) {
+          // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module
+          // Module['forcedAspectRatio'] = 4 / 3;
+          
+          canvas.requestPointerLock = canvas['requestPointerLock'] ||
+                                      canvas['mozRequestPointerLock'] ||
+                                      canvas['webkitRequestPointerLock'] ||
+                                      canvas['msRequestPointerLock'] ||
+                                      function(){};
+          canvas.exitPointerLock = document['exitPointerLock'] ||
+                                   document['mozExitPointerLock'] ||
+                                   document['webkitExitPointerLock'] ||
+                                   document['msExitPointerLock'] ||
+                                   function(){}; // no-op if function does not exist
+          canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+  
+          document.addEventListener('pointerlockchange', pointerLockChange, false);
+          document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+          document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+          document.addEventListener('mspointerlockchange', pointerLockChange, false);
+  
+          if (Module['elementPointerLock']) {
+            canvas.addEventListener("click", function(ev) {
+              if (!Browser.pointerLock && Module['canvas'].requestPointerLock) {
+                Module['canvas'].requestPointerLock();
+                ev.preventDefault();
+              }
+            }, false);
+          }
+        }
+      },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) {
+        if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; // no need to recreate GL context if it's already been created for this canvas.
+  
+        var ctx;
+        var contextHandle;
+        if (useWebGL) {
+          // For GLES2/desktop GL compatibility, adjust a few defaults to be different to WebGL defaults, so that they align better with the desktop defaults.
+          var contextAttributes = {
+            antialias: false,
+            alpha: false
+          };
+  
+          if (webGLContextAttributes) {
+            for (var attribute in webGLContextAttributes) {
+              contextAttributes[attribute] = webGLContextAttributes[attribute];
+            }
+          }
+  
+          contextHandle = GL.createContext(canvas, contextAttributes);
+          if (contextHandle) {
+            ctx = GL.getContext(contextHandle).GLctx;
+          }
+        } else {
+          ctx = canvas.getContext('2d');
+        }
+  
+        if (!ctx) return null;
+  
+        if (setInModule) {
+          if (!useWebGL) assert(typeof GLctx === 'undefined', 'cannot set in module if GLctx is used, but we are a non-GL context that would replace it');
+  
+          Module.ctx = ctx;
+          if (useWebGL) GL.makeContextCurrent(contextHandle);
+          Module.useWebGL = useWebGL;
+          Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() });
+          Browser.init();
+        }
+        return ctx;
+      },destroyContext:function (canvas, useWebGL, setInModule) {},fullscreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullscreen:function (lockPointer, resizeCanvas, vrDevice) {
+        Browser.lockPointer = lockPointer;
+        Browser.resizeCanvas = resizeCanvas;
+        Browser.vrDevice = vrDevice;
+        if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+        if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+        if (typeof Browser.vrDevice === 'undefined') Browser.vrDevice = null;
+  
+        var canvas = Module['canvas'];
+        function fullscreenChange() {
+          Browser.isFullscreen = false;
+          var canvasContainer = canvas.parentNode;
+          if ((document['fullscreenElement'] || document['mozFullScreenElement'] ||
+               document['msFullscreenElement'] || document['webkitFullscreenElement'] ||
+               document['webkitCurrentFullScreenElement']) === canvasContainer) {
+            canvas.exitFullscreen = document['exitFullscreen'] ||
+                                    document['cancelFullScreen'] ||
+                                    document['mozCancelFullScreen'] ||
+                                    document['msExitFullscreen'] ||
+                                    document['webkitCancelFullScreen'] ||
+                                    function() {};
+            canvas.exitFullscreen = canvas.exitFullscreen.bind(document);
+            if (Browser.lockPointer) canvas.requestPointerLock();
+            Browser.isFullscreen = true;
+            if (Browser.resizeCanvas) Browser.setFullscreenCanvasSize();
+          } else {
+            
+            // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen
+            canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
+            canvasContainer.parentNode.removeChild(canvasContainer);
+            
+            if (Browser.resizeCanvas) Browser.setWindowedCanvasSize();
+          }
+          if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullscreen);
+          if (Module['onFullscreen']) Module['onFullscreen'](Browser.isFullscreen);
+          Browser.updateCanvasDimensions(canvas);
+        }
+  
+        if (!Browser.fullscreenHandlersInstalled) {
+          Browser.fullscreenHandlersInstalled = true;
+          document.addEventListener('fullscreenchange', fullscreenChange, false);
+          document.addEventListener('mozfullscreenchange', fullscreenChange, false);
+          document.addEventListener('webkitfullscreenchange', fullscreenChange, false);
+          document.addEventListener('MSFullscreenChange', fullscreenChange, false);
+        }
+  
+        // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root
+        var canvasContainer = document.createElement("div");
+        canvas.parentNode.insertBefore(canvasContainer, canvas);
+        canvasContainer.appendChild(canvas);
+  
+        // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size)
+        canvasContainer.requestFullscreen = canvasContainer['requestFullscreen'] ||
+                                            canvasContainer['mozRequestFullScreen'] ||
+                                            canvasContainer['msRequestFullscreen'] ||
+                                           (canvasContainer['webkitRequestFullscreen'] ? function() { canvasContainer['webkitRequestFullscreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null) ||
+                                           (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null);
+  
+        if (vrDevice) {
+          canvasContainer.requestFullscreen({ vrDisplay: vrDevice });
+        } else {
+          canvasContainer.requestFullscreen();
+        }
+      },requestFullScreen:function (lockPointer, resizeCanvas, vrDevice) {
+          Module.printErr('Browser.requestFullScreen() is deprecated. Please call Browser.requestFullscreen instead.');
+          Browser.requestFullScreen = function(lockPointer, resizeCanvas, vrDevice) {
+            return Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice);
+          }
+          return Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice);
+      },nextRAF:0,fakeRequestAnimationFrame:function (func) {
+        // try to keep 60fps between calls to here
+        var now = Date.now();
+        if (Browser.nextRAF === 0) {
+          Browser.nextRAF = now + 1000/60;
+        } else {
+          while (now + 2 >= Browser.nextRAF) { // fudge a little, to avoid timer jitter causing us to do lots of delay:0
+            Browser.nextRAF += 1000/60;
+          }
+        }
+        var delay = Math.max(Browser.nextRAF - now, 0);
+        setTimeout(func, delay);
+      },requestAnimationFrame:function requestAnimationFrame(func) {
+        if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+          Browser.fakeRequestAnimationFrame(func);
+        } else {
+          if (!window.requestAnimationFrame) {
+            window.requestAnimationFrame = window['requestAnimationFrame'] ||
+                                           window['mozRequestAnimationFrame'] ||
+                                           window['webkitRequestAnimationFrame'] ||
+                                           window['msRequestAnimationFrame'] ||
+                                           window['oRequestAnimationFrame'] ||
+                                           Browser.fakeRequestAnimationFrame;
+          }
+          window.requestAnimationFrame(func);
+        }
+      },safeCallback:function (func) {
+        return function() {
+          if (!ABORT) return func.apply(null, arguments);
+        };
+      },allowAsyncCallbacks:true,queuedAsyncCallbacks:[],pauseAsyncCallbacks:function () {
+        Browser.allowAsyncCallbacks = false;
+      },resumeAsyncCallbacks:function () { // marks future callbacks as ok to execute, and synchronously runs any remaining ones right now
+        Browser.allowAsyncCallbacks = true;
+        if (Browser.queuedAsyncCallbacks.length > 0) {
+          var callbacks = Browser.queuedAsyncCallbacks;
+          Browser.queuedAsyncCallbacks = [];
+          callbacks.forEach(function(func) {
+            func();
+          });
+        }
+      },safeRequestAnimationFrame:function (func) {
+        return Browser.requestAnimationFrame(function() {
+          if (ABORT) return;
+          if (Browser.allowAsyncCallbacks) {
+            func();
+          } else {
+            Browser.queuedAsyncCallbacks.push(func);
+          }
+        });
+      },safeSetTimeout:function (func, timeout) {
+        Module['noExitRuntime'] = true;
+        return setTimeout(function() {
+          if (ABORT) return;
+          if (Browser.allowAsyncCallbacks) {
+            func();
+          } else {
+            Browser.queuedAsyncCallbacks.push(func);
+          }
+        }, timeout);
+      },safeSetInterval:function (func, timeout) {
+        Module['noExitRuntime'] = true;
+        return setInterval(function() {
+          if (ABORT) return;
+          if (Browser.allowAsyncCallbacks) {
+            func();
+          } // drop it on the floor otherwise, next interval will kick in
+        }, timeout);
+      },getMimetype:function (name) {
+        return {
+          'jpg': 'image/jpeg',
+          'jpeg': 'image/jpeg',
+          'png': 'image/png',
+          'bmp': 'image/bmp',
+          'ogg': 'audio/ogg',
+          'wav': 'audio/wav',
+          'mp3': 'audio/mpeg'
+        }[name.substr(name.lastIndexOf('.')+1)];
+      },getUserMedia:function (func) {
+        if(!window.getUserMedia) {
+          window.getUserMedia = navigator['getUserMedia'] ||
+                                navigator['mozGetUserMedia'];
+        }
+        window.getUserMedia(func);
+      },getMovementX:function (event) {
+        return event['movementX'] ||
+               event['mozMovementX'] ||
+               event['webkitMovementX'] ||
+               0;
+      },getMovementY:function (event) {
+        return event['movementY'] ||
+               event['mozMovementY'] ||
+               event['webkitMovementY'] ||
+               0;
+      },getMouseWheelDelta:function (event) {
+        var delta = 0;
+        switch (event.type) {
+          case 'DOMMouseScroll': 
+            delta = event.detail;
+            break;
+          case 'mousewheel': 
+            delta = event.wheelDelta;
+            break;
+          case 'wheel': 
+            delta = event['deltaY'];
+            break;
+          default:
+            throw 'unrecognized mouse wheel event: ' + event.type;
+        }
+        return delta;
+      },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,touches:{},lastTouches:{},calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup
+        if (Browser.pointerLock) {
+          // When the pointer is locked, calculate the coordinates
+          // based on the movement of the mouse.
+          // Workaround for Firefox bug 764498
+          if (event.type != 'mousemove' &&
+              ('mozMovementX' in event)) {
+            Browser.mouseMovementX = Browser.mouseMovementY = 0;
+          } else {
+            Browser.mouseMovementX = Browser.getMovementX(event);
+            Browser.mouseMovementY = Browser.getMovementY(event);
+          }
+          
+          // check if SDL is available
+          if (typeof SDL != "undefined") {
+          	Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+          	Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+          } else {
+          	// just add the mouse delta to the current absolut mouse position
+          	// FIXME: ideally this should be clamped against the canvas size and zero
+          	Browser.mouseX += Browser.mouseMovementX;
+          	Browser.mouseY += Browser.mouseMovementY;
+          }        
+        } else {
+          // Otherwise, calculate the movement based on the changes
+          // in the coordinates.
+          var rect = Module["canvas"].getBoundingClientRect();
+          var cw = Module["canvas"].width;
+          var ch = Module["canvas"].height;
+  
+          // Neither .scrollX or .pageXOffset are defined in a spec, but
+          // we prefer .scrollX because it is currently in a spec draft.
+          // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+          var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+          var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+  
+          if (event.type === 'touchstart' || event.type === 'touchend' || event.type === 'touchmove') {
+            var touch = event.touch;
+            if (touch === undefined) {
+              return; // the "touch" property is only defined in SDL
+  
+            }
+            var adjustedX = touch.pageX - (scrollX + rect.left);
+            var adjustedY = touch.pageY - (scrollY + rect.top);
+  
+            adjustedX = adjustedX * (cw / rect.width);
+            adjustedY = adjustedY * (ch / rect.height);
+  
+            var coords = { x: adjustedX, y: adjustedY };
+            
+            if (event.type === 'touchstart') {
+              Browser.lastTouches[touch.identifier] = coords;
+              Browser.touches[touch.identifier] = coords;
+            } else if (event.type === 'touchend' || event.type === 'touchmove') {
+              var last = Browser.touches[touch.identifier];
+              if (!last) last = coords;
+              Browser.lastTouches[touch.identifier] = last;
+              Browser.touches[touch.identifier] = coords;
+            } 
+            return;
+          }
+  
+          var x = event.pageX - (scrollX + rect.left);
+          var y = event.pageY - (scrollY + rect.top);
+  
+          // the canvas might be CSS-scaled compared to its backbuffer;
+          // SDL-using content will want mouse coordinates in terms
+          // of backbuffer units.
+          x = x * (cw / rect.width);
+          y = y * (ch / rect.height);
+  
+          Browser.mouseMovementX = x - Browser.mouseX;
+          Browser.mouseMovementY = y - Browser.mouseY;
+          Browser.mouseX = x;
+          Browser.mouseY = y;
+        }
+      },asyncLoad:function (url, onload, onerror, noRunDep) {
+        var dep = !noRunDep ? getUniqueRunDependency('al ' + url) : '';
+        Module['readAsync'](url, function(arrayBuffer) {
+          assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+          onload(new Uint8Array(arrayBuffer));
+          if (dep) removeRunDependency(dep);
+        }, function(event) {
+          if (onerror) {
+            onerror();
+          } else {
+            throw 'Loading data file "' + url + '" failed.';
+          }
+        });
+        if (dep) addRunDependency(dep);
+      },resizeListeners:[],updateResizeListeners:function () {
+        var canvas = Module['canvas'];
+        Browser.resizeListeners.forEach(function(listener) {
+          listener(canvas.width, canvas.height);
+        });
+      },setCanvasSize:function (width, height, noUpdates) {
+        var canvas = Module['canvas'];
+        Browser.updateCanvasDimensions(canvas, width, height);
+        if (!noUpdates) Browser.updateResizeListeners();
+      },windowedWidth:0,windowedHeight:0,setFullscreenCanvasSize:function () {
+        // check if SDL is available   
+        if (typeof SDL != "undefined") {
+        	var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+        	flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+        	HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+        }
+        Browser.updateResizeListeners();
+      },setWindowedCanvasSize:function () {
+        // check if SDL is available       
+        if (typeof SDL != "undefined") {
+        	var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
+        	flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+        	HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
+        }
+        Browser.updateResizeListeners();
+      },updateCanvasDimensions:function (canvas, wNative, hNative) {
+        if (wNative && hNative) {
+          canvas.widthNative = wNative;
+          canvas.heightNative = hNative;
+        } else {
+          wNative = canvas.widthNative;
+          hNative = canvas.heightNative;
+        }
+        var w = wNative;
+        var h = hNative;
+        if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
+          if (w/h < Module['forcedAspectRatio']) {
+            w = Math.round(h * Module['forcedAspectRatio']);
+          } else {
+            h = Math.round(w / Module['forcedAspectRatio']);
+          }
+        }
+        if (((document['fullscreenElement'] || document['mozFullScreenElement'] ||
+             document['msFullscreenElement'] || document['webkitFullscreenElement'] ||
+             document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) {
+           var factor = Math.min(screen.width / w, screen.height / h);
+           w = Math.round(w * factor);
+           h = Math.round(h * factor);
+        }
+        if (Browser.resizeCanvas) {
+          if (canvas.width  != w) canvas.width  = w;
+          if (canvas.height != h) canvas.height = h;
+          if (typeof canvas.style != 'undefined') {
+            canvas.style.removeProperty( "width");
+            canvas.style.removeProperty("height");
+          }
+        } else {
+          if (canvas.width  != wNative) canvas.width  = wNative;
+          if (canvas.height != hNative) canvas.height = hNative;
+          if (typeof canvas.style != 'undefined') {
+            if (w != wNative || h != hNative) {
+              canvas.style.setProperty( "width", w + "px", "important");
+              canvas.style.setProperty("height", h + "px", "important");
+            } else {
+              canvas.style.removeProperty( "width");
+              canvas.style.removeProperty("height");
+            }
+          }
+        }
+      },wgetRequests:{},nextWgetRequestHandle:0,getNextWgetRequestHandle:function () {
+        var handle = Browser.nextWgetRequestHandle;
+        Browser.nextWgetRequestHandle++;
+        return handle;
+      }};function _emscripten_set_main_loop_timing(mode, value) {
+      Browser.mainLoop.timingMode = mode;
+      Browser.mainLoop.timingValue = value;
+  
+      if (!Browser.mainLoop.func) {
+        return 1; // Return non-zero on failure, can't set timing mode when there is no main loop.
+      }
+  
+      if (mode == 0 /*EM_TIMING_SETTIMEOUT*/) {
+        Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() {
+          var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now())|0;
+          setTimeout(Browser.mainLoop.runner, timeUntilNextTick); // doing this each time means that on exception, we stop
+        };
+        Browser.mainLoop.method = 'timeout';
+      } else if (mode == 1 /*EM_TIMING_RAF*/) {
+        Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
+          Browser.requestAnimationFrame(Browser.mainLoop.runner);
+        };
+        Browser.mainLoop.method = 'rAF';
+      } else if (mode == 2 /*EM_TIMING_SETIMMEDIATE*/) {
+        if (!window['setImmediate']) {
+          // Emulate setImmediate. (note: not a complete polyfill, we don't emulate clearImmediate() to keep code size to minimum, since not needed)
+          var setImmediates = [];
+          var emscriptenMainLoopMessageId = 'setimmediate';
+          function Browser_setImmediate_messageHandler(event) {
+            if (event.source === window && event.data === emscriptenMainLoopMessageId) {
+              event.stopPropagation();
+              setImmediates.shift()();
+            }
+          }
+          window.addEventListener("message", Browser_setImmediate_messageHandler, true);
+          window['setImmediate'] = function Browser_emulated_setImmediate(func) {
+            setImmediates.push(func);
+          }
+        }
+        Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() {
+          window['setImmediate'](Browser.mainLoop.runner);
+        };
+        Browser.mainLoop.method = 'immediate';
+      }
+      return 0;
+    }
+  
+  function _emscripten_get_now() { abort() }function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg, noSetTiming) {
+      Module['noExitRuntime'] = true;
+  
+      assert(!Browser.mainLoop.func, 'emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.');
+  
+      Browser.mainLoop.func = func;
+      Browser.mainLoop.arg = arg;
+  
+      var browserIterationFunc;
+      if (typeof arg !== 'undefined') {
+        browserIterationFunc = function() {
+          Module['dynCall_vi'](func, arg);
+        };
+      } else {
+        browserIterationFunc = function() {
+          Module['dynCall_v'](func);
+        };
+      }
+  
+      var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;
+  
+      Browser.mainLoop.runner = function Browser_mainLoop_runner() {
+        if (ABORT) return;
+        if (Browser.mainLoop.queue.length > 0) {
+          var start = Date.now();
+          var blocker = Browser.mainLoop.queue.shift();
+          blocker.func(blocker.arg);
+          if (Browser.mainLoop.remainingBlockers) {
+            var remaining = Browser.mainLoop.remainingBlockers;
+            var next = remaining%1 == 0 ? remaining-1 : Math.floor(remaining);
+            if (blocker.counted) {
+              Browser.mainLoop.remainingBlockers = next;
+            } else {
+              // not counted, but move the progress along a tiny bit
+              next = next + 0.5; // do not steal all the next one's progress
+              Browser.mainLoop.remainingBlockers = (8*remaining + next)/9;
+            }
+          }
+          console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + ' ms'); //, left: ' + Browser.mainLoop.remainingBlockers);
+          Browser.mainLoop.updateStatus();
+          
+          // catches pause/resume main loop from blocker execution
+          if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
+          
+          setTimeout(Browser.mainLoop.runner, 0);
+          return;
+        }
+  
+        // catch pauses from non-main loop sources
+        if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
+  
+        // Implement very basic swap interval control
+        Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0;
+        if (Browser.mainLoop.timingMode == 1/*EM_TIMING_RAF*/ && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) {
+          // Not the scheduled time to render this frame - skip.
+          Browser.mainLoop.scheduler();
+          return;
+        } else if (Browser.mainLoop.timingMode == 0/*EM_TIMING_SETTIMEOUT*/) {
+          Browser.mainLoop.tickStartTime = _emscripten_get_now();
+        }
+  
+        // Signal GL rendering layer that processing of a new frame is about to start. This helps it optimize
+        // VBO double-buffering and reduce GPU stalls.
+  
+  
+        if (Browser.mainLoop.method === 'timeout' && Module.ctx) {
+          Module.printErr('Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!');
+          Browser.mainLoop.method = ''; // just warn once per call to set main loop
+        }
+  
+        Browser.mainLoop.runIter(browserIterationFunc);
+  
+  
+        // catch pauses from the main loop itself
+        if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return;
+  
+        // Queue new audio data. This is important to be right after the main loop invocation, so that we will immediately be able
+        // to queue the newest produced audio samples.
+        // TODO: Consider adding pre- and post- rAF callbacks so that GL.newRenderingFrameStarted() and SDL.audio.queueNewAudioData()
+        //       do not need to be hardcoded into this function, but can be more generic.
+        if (typeof SDL === 'object' && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData();
+  
+        Browser.mainLoop.scheduler();
+      }
+  
+      if (!noSetTiming) {
+        if (fps && fps > 0) _emscripten_set_main_loop_timing(0/*EM_TIMING_SETTIMEOUT*/, 1000.0 / fps);
+        else _emscripten_set_main_loop_timing(1/*EM_TIMING_RAF*/, 1); // Do rAF by rendering each frame (no decimating)
+  
+        Browser.mainLoop.scheduler();
+      }
+  
+      if (simulateInfiniteLoop) {
+        throw 'SimulateInfiniteLoop';
+      }
+    }
+
+   
+  Module["_memset"] = _memset;
+
+  function _pthread_cleanup_push(routine, arg) {
+      __ATEXIT__.push(function() { Module['dynCall_vi'](routine, arg) })
+      _pthread_cleanup_push.level = __ATEXIT__.length;
+    }
+
+  function _pthread_cleanup_pop() {
+      assert(_pthread_cleanup_push.level == __ATEXIT__.length, 'cannot pop if something else added meanwhile!');
+      __ATEXIT__.pop();
+      _pthread_cleanup_push.level = __ATEXIT__.length;
+    }
+
+  function _abort() {
+      Module['abort']();
+    }
+
+  
+  function __ZSt18uncaught_exceptionv() { // std::uncaught_exception()
+      return !!__ZSt18uncaught_exceptionv.uncaught_exception;
+    }
+  
+  var EXCEPTIONS={last:0,caught:[],infos:{},deAdjust:function (adjusted) {
+        if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted;
+        for (var ptr in EXCEPTIONS.infos) {
+          var info = EXCEPTIONS.infos[ptr];
+          if (info.adjusted === adjusted) {
+            return ptr;
+          }
+        }
+        return adjusted;
+      },addRef:function (ptr) {
+        if (!ptr) return;
+        var info = EXCEPTIONS.infos[ptr];
+        info.refcount++;
+      },decRef:function (ptr) {
+        if (!ptr) return;
+        var info = EXCEPTIONS.infos[ptr];
+        assert(info.refcount > 0);
+        info.refcount--;
+        // A rethrown exception can reach refcount 0; it must not be discarded
+        // Its next handler will clear the rethrown flag and addRef it, prior to
+        // final decRef and destruction here
+        if (info.refcount === 0 && !info.rethrown) {
+          if (info.destructor) {
+            Module['dynCall_vi'](info.destructor, ptr);
+          }
+          delete EXCEPTIONS.infos[ptr];
+          ___cxa_free_exception(ptr);
+        }
+      },clearRef:function (ptr) {
+        if (!ptr) return;
+        var info = EXCEPTIONS.infos[ptr];
+        info.refcount = 0;
+      }};function ___cxa_begin_catch(ptr) {
+      var info = EXCEPTIONS.infos[ptr];
+      if (info && !info.caught) {
+        info.caught = true;
+        __ZSt18uncaught_exceptionv.uncaught_exception--;
+      }
+      if (info) info.rethrown = false;
+      EXCEPTIONS.caught.push(ptr);
+      EXCEPTIONS.addRef(EXCEPTIONS.deAdjust(ptr));
+      return ptr;
+    }
+
+  function _pthread_once(ptr, func) {
+      if (!_pthread_once.seen) _pthread_once.seen = {};
+      if (ptr in _pthread_once.seen) return;
+      Module['dynCall_v'](func);
+      _pthread_once.seen[ptr] = 1;
+    }
+
+  function ___lock() {}
+
+  function ___unlock() {}
+
+  
+  var SYSCALLS={varargs:0,get:function (varargs) {
+        SYSCALLS.varargs += 4;
+        var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)];
+        return ret;
+      },getStr:function () {
+        var ret = Pointer_stringify(SYSCALLS.get());
+        return ret;
+      },get64:function () {
+        var low = SYSCALLS.get(), high = SYSCALLS.get();
+        if (low >= 0) assert(high === 0);
+        else assert(high === -1);
+        return low;
+      },getZero:function () {
+        assert(SYSCALLS.get() === 0);
+      }};function ___syscall6(which, varargs) {SYSCALLS.varargs = varargs;
+  try {
+   // close
+      var stream = SYSCALLS.getStreamFromFD();
+      FS.close(stream);
+      return 0;
+    } catch (e) {
+    if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
+    return -e.errno;
+  }
+  }
+
+  
+  var PTHREAD_SPECIFIC={};function _pthread_getspecific(key) {
+      return PTHREAD_SPECIFIC[key] || 0;
+    }
+
+  
+  function ___setErrNo(value) {
+      if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value;
+      return value;
+    } 
+  Module["_sbrk"] = _sbrk;
+
+  function _clock() {
+      if (_clock.start === undefined) _clock.start = Date.now();
+      return ((Date.now() - _clock.start) * (1000000 / 1000))|0;
+    }
+
+  
+  var PTHREAD_SPECIFIC_NEXT_KEY=1;
+  
+  var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};function _pthread_key_create(key, destructor) {
+      if (key == 0) {
+        return ERRNO_CODES.EINVAL;
+      }
+      HEAP32[((key)>>2)]=PTHREAD_SPECIFIC_NEXT_KEY;
+      // values start at 0
+      PTHREAD_SPECIFIC[PTHREAD_SPECIFIC_NEXT_KEY] = 0;
+      PTHREAD_SPECIFIC_NEXT_KEY++;
+      return 0;
+    }
+
+  
+  
+  function ___resumeException(ptr) {
+      if (!EXCEPTIONS.last) { EXCEPTIONS.last = ptr; }
+      throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";
+    }function ___cxa_find_matching_catch() {
+      var thrown = EXCEPTIONS.last;
+      if (!thrown) {
+        // just pass through the null ptr
+        return ((Runtime.setTempRet0(0),0)|0);
+      }
+      var info = EXCEPTIONS.infos[thrown];
+      var throwntype = info.type;
+      if (!throwntype) {
+        // just pass through the thrown ptr
+        return ((Runtime.setTempRet0(0),thrown)|0);
+      }
+      var typeArray = Array.prototype.slice.call(arguments);
+  
+      var pointer = Module['___cxa_is_pointer_type'](throwntype);
+      // can_catch receives a **, add indirection
+      if (!___cxa_find_matching_catch.buffer) ___cxa_find_matching_catch.buffer = _malloc(4);
+      HEAP32[((___cxa_find_matching_catch.buffer)>>2)]=thrown;
+      thrown = ___cxa_find_matching_catch.buffer;
+      // The different catch blocks are denoted by different types.
+      // Due to inheritance, those types may not precisely match the
+      // type of the thrown object. Find one which matches, and
+      // return the type of the catch block which should be called.
+      for (var i = 0; i < typeArray.length; i++) {
+        if (typeArray[i] && Module['___cxa_can_catch'](typeArray[i], throwntype, thrown)) {
+          thrown = HEAP32[((thrown)>>2)]; // undo indirection
+          info.adjusted = thrown;
+          return ((Runtime.setTempRet0(typeArray[i]),thrown)|0);
+        }
+      }
+      // Shouldn't happen unless we have bogus data in typeArray
+      // or encounter a type for which emscripten doesn't have suitable
+      // typeinfo defined. Best-efforts match just in case.
+      thrown = HEAP32[((thrown)>>2)]; // undo indirection
+      return ((Runtime.setTempRet0(throwntype),thrown)|0);
+    }function ___gxx_personality_v0() {
+    }
+
+  
+  function _emscripten_memcpy_big(dest, src, num) {
+      HEAPU8.set(HEAPU8.subarray(src, src+num), dest);
+      return dest;
+    } 
+  Module["_memcpy"] = _memcpy;
+
+  function ___syscall140(which, varargs) {SYSCALLS.varargs = varargs;
+  try {
+   // llseek
+      var stream = SYSCALLS.getStreamFromFD(), offset_high = SYSCALLS.get(), offset_low = SYSCALLS.get(), result = SYSCALLS.get(), whence = SYSCALLS.get();
+      var offset = offset_low;
+      assert(offset_high === 0);
+      FS.llseek(stream, offset, whence);
+      HEAP32[((result)>>2)]=stream.position;
+      if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state
+      return 0;
+    } catch (e) {
+    if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
+    return -e.errno;
+  }
+  }
+
+  function _pthread_setspecific(key, value) {
+      if (!(key in PTHREAD_SPECIFIC)) {
+        return ERRNO_CODES.EINVAL;
+      }
+      PTHREAD_SPECIFIC[key] = value;
+      return 0;
+    }
+
+   
+  Module["_pthread_self"] = _pthread_self;
+
+  function _emscripten_cancel_main_loop() {
+      Browser.mainLoop.pause();
+      Browser.mainLoop.func = null;
+    }
+
+  function _emscripten_run_script(ptr) {
+      eval(Pointer_stringify(ptr));
+    }
+
+  function ___syscall146(which, varargs) {SYSCALLS.varargs = varargs;
+  try {
+   // writev
+      // hack to support printf in NO_FILESYSTEM
+      var stream = SYSCALLS.get(), iov = SYSCALLS.get(), iovcnt = SYSCALLS.get();
+      var ret = 0;
+      if (!___syscall146.buffer) {
+        ___syscall146.buffers = [null, [], []]; // 1 => stdout, 2 => stderr
+        ___syscall146.printChar = function(stream, curr) {
+          var buffer = ___syscall146.buffers[stream];
+          assert(buffer);
+          if (curr === 0 || curr === 10) {
+            (stream === 1 ? Module['print'] : Module['printErr'])(UTF8ArrayToString(buffer, 0));
+            buffer.length = 0;
+          } else {
+            buffer.push(curr);
+          }
+        };
+      }
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAP32[(((iov)+(i*8))>>2)];
+        var len = HEAP32[(((iov)+(i*8 + 4))>>2)];
+        for (var j = 0; j < len; j++) {
+          ___syscall146.printChar(stream, HEAPU8[ptr+j]);
+        }
+        ret += len;
+      }
+      return ret;
+    } catch (e) {
+    if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
+    return -e.errno;
+  }
+  }
+
+  function ___syscall54(which, varargs) {SYSCALLS.varargs = varargs;
+  try {
+   // ioctl
+      return 0;
+    } catch (e) {
+    if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e);
+    return -e.errno;
+  }
+  }
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas, vrDevice) { Module.printErr("Module.requestFullScreen is deprecated. Please call Module.requestFullscreen instead."); Module["requestFullScreen"] = Module["requestFullscreen"]; Browser.requestFullScreen(lockPointer, resizeCanvas, vrDevice) };
+  Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas, vrDevice) { Browser.requestFullscreen(lockPointer, resizeCanvas, vrDevice) };
+  Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) };
+  Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) };
+  Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() };
+  Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() };
+  Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() }
+  Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) { return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes) };
+  if (typeof dateNow !== 'undefined') {
+    _emscripten_get_now = dateNow;
+  } else if (typeof self === 'object' && self['performance'] && typeof self['performance']['now'] === 'function') {
+    _emscripten_get_now = function() { return self['performance']['now'](); };
+  } else if (typeof performance === 'object' && typeof performance['now'] === 'function') {
+    _emscripten_get_now = function() { return performance['now'](); };
+  } else {
+    _emscripten_get_now = Date.now;
+  };
+/* flush anything remaining in the buffer during shutdown */ __ATEXIT__.push(function() { var fflush = Module["_fflush"]; if (fflush) fflush(0); var printChar = ___syscall146.printChar; if (!printChar) return; var buffers = ___syscall146.buffers; if (buffers[1].length) printChar(1, 10); if (buffers[2].length) printChar(2, 10); });;
+DYNAMICTOP_PTR = allocate(1, "i32", ALLOC_STATIC);
+
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+STACK_MAX = STACK_BASE + TOTAL_STACK;
+
+DYNAMIC_BASE = Runtime.alignMemory(STACK_MAX);
+
+HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE;
+
+staticSealed = true; // seal the static portion of memory
+
+
+
+Module['wasmTableSize'] = 120;
+
+Module['wasmMaxTableSize'] = 120;
+
+function invoke_iiii(index,a1,a2,a3) {
+  try {
+    return Module["dynCall_iiii"](index,a1,a2,a3);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_viiiii(index,a1,a2,a3,a4,a5) {
+  try {
+    Module["dynCall_viiiii"](index,a1,a2,a3,a4,a5);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_vi(index,a1) {
+  try {
+    Module["dynCall_vi"](index,a1);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_vii(index,a1,a2) {
+  try {
+    Module["dynCall_vii"](index,a1,a2);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_ii(index,a1) {
+  try {
+    return Module["dynCall_ii"](index,a1);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_viii(index,a1,a2,a3) {
+  try {
+    Module["dynCall_viii"](index,a1,a2,a3);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_v(index) {
+  try {
+    Module["dynCall_v"](index);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_viif(index,a1,a2,a3) {
+  try {
+    Module["dynCall_viif"](index,a1,a2,a3);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_viiiiii(index,a1,a2,a3,a4,a5,a6) {
+  try {
+    Module["dynCall_viiiiii"](index,a1,a2,a3,a4,a5,a6);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_iii(index,a1,a2) {
+  try {
+    return Module["dynCall_iii"](index,a1,a2);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_iiiiii(index,a1,a2,a3,a4,a5) {
+  try {
+    return Module["dynCall_iiiiii"](index,a1,a2,a3,a4,a5);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+function invoke_viiii(index,a1,a2,a3,a4) {
+  try {
+    Module["dynCall_viiii"](index,a1,a2,a3,a4);
+  } catch(e) {
+    if (typeof e !== 'number' && e !== 'longjmp') throw e;
+    Module["setThrew"](1, 0);
+  }
+}
+
+Module.asmGlobalArg = { "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array, "NaN": NaN, "Infinity": Infinity };
+
+Module.asmLibraryArg = { "abort": abort, "assert": assert, "enlargeMemory": enlargeMemory, "getTotalMemory": getTotalMemory, "abortOnCannotGrowMemory": abortOnCannotGrowMemory, "invoke_iiii": invoke_iiii, "invoke_viiiii": invoke_viiiii, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_ii": invoke_ii, "invoke_viii": invoke_viii, "invoke_v": invoke_v, "invoke_viif": invoke_viif, "invoke_viiiiii": invoke_viiiiii, "invoke_iii": invoke_iii, "invoke_iiiiii": invoke_iiiiii, "invoke_viiii": invoke_viiii, "_pthread_cleanup_pop": _pthread_cleanup_pop, "_emscripten_run_script": _emscripten_run_script, "_pthread_key_create": _pthread_key_create, "___syscall6": ___syscall6, "___setErrNo": ___setErrNo, "___gxx_personality_v0": ___gxx_personality_v0, "___assert_fail": ___assert_fail, "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv, "_emscripten_set_main_loop_timing": _emscripten_set_main_loop_timing, "___cxa_begin_catch": ___cxa_begin_catch, "_emscripten_memcpy_big": _emscripten_memcpy_big, "___resumeException": ___resumeException, "___cxa_find_matching_catch": ___cxa_find_matching_catch, "_pthread_getspecific": _pthread_getspecific, "_clock": _clock, "_pthread_once": _pthread_once, "___syscall54": ___syscall54, "___unlock": ___unlock, "_emscripten_set_main_loop": _emscripten_set_main_loop, "_emscripten_get_now": _emscripten_get_now, "_pthread_setspecific": _pthread_setspecific, "___lock": ___lock, "_abort": _abort, "_pthread_cleanup_push": _pthread_cleanup_push, "_emscripten_cancel_main_loop": _emscripten_cancel_main_loop, "___syscall140": ___syscall140, "___cxa_pure_virtual": ___cxa_pure_virtual, "___syscall146": ___syscall146, "DYNAMICTOP_PTR": DYNAMICTOP_PTR, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX };
+// EMSCRIPTEN_START_ASM
+var asm =Module["asm"]// EMSCRIPTEN_END_ASM
+(Module.asmGlobalArg, Module.asmLibraryArg, buffer);
+
+Module["asm"] = asm;
+var _malloc = Module["_malloc"] = function() { return Module["asm"]["_malloc"].apply(null, arguments) };
+var ___cxa_can_catch = Module["___cxa_can_catch"] = function() { return Module["asm"]["___cxa_can_catch"].apply(null, arguments) };
+var getTempRet0 = Module["getTempRet0"] = function() { return Module["asm"]["getTempRet0"].apply(null, arguments) };
+var _free = Module["_free"] = function() { return Module["asm"]["_free"].apply(null, arguments) };
+var _main = Module["_main"] = function() { return Module["asm"]["_main"].apply(null, arguments) };
+var setTempRet0 = Module["setTempRet0"] = function() { return Module["asm"]["setTempRet0"].apply(null, arguments) };
+var ___cxa_is_pointer_type = Module["___cxa_is_pointer_type"] = function() { return Module["asm"]["___cxa_is_pointer_type"].apply(null, arguments) };
+var establishStackSpace = Module["establishStackSpace"] = function() { return Module["asm"]["establishStackSpace"].apply(null, arguments) };
+var _pthread_self = Module["_pthread_self"] = function() { return Module["asm"]["_pthread_self"].apply(null, arguments) };
+var stackSave = Module["stackSave"] = function() { return Module["asm"]["stackSave"].apply(null, arguments) };
+var _memset = Module["_memset"] = function() { return Module["asm"]["_memset"].apply(null, arguments) };
+var _sbrk = Module["_sbrk"] = function() { return Module["asm"]["_sbrk"].apply(null, arguments) };
+var stackRestore = Module["stackRestore"] = function() { return Module["asm"]["stackRestore"].apply(null, arguments) };
+var _memcpy = Module["_memcpy"] = function() { return Module["asm"]["_memcpy"].apply(null, arguments) };
+var stackAlloc = Module["stackAlloc"] = function() { return Module["asm"]["stackAlloc"].apply(null, arguments) };
+var setThrew = Module["setThrew"] = function() { return Module["asm"]["setThrew"].apply(null, arguments) };
+var _fflush = Module["_fflush"] = function() { return Module["asm"]["_fflush"].apply(null, arguments) };
+var ___errno_location = Module["___errno_location"] = function() { return Module["asm"]["___errno_location"].apply(null, arguments) };
+var runPostSets = Module["runPostSets"] = function() { return Module["asm"]["runPostSets"].apply(null, arguments) };
+var dynCall_iiii = Module["dynCall_iiii"] = function() { return Module["asm"]["dynCall_iiii"].apply(null, arguments) };
+var dynCall_viiiii = Module["dynCall_viiiii"] = function() { return Module["asm"]["dynCall_viiiii"].apply(null, arguments) };
+var dynCall_vi = Module["dynCall_vi"] = function() { return Module["asm"]["dynCall_vi"].apply(null, arguments) };
+var dynCall_vii = Module["dynCall_vii"] = function() { return Module["asm"]["dynCall_vii"].apply(null, arguments) };
+var dynCall_ii = Module["dynCall_ii"] = function() { return Module["asm"]["dynCall_ii"].apply(null, arguments) };
+var dynCall_viii = Module["dynCall_viii"] = function() { return Module["asm"]["dynCall_viii"].apply(null, arguments) };
+var dynCall_v = Module["dynCall_v"] = function() { return Module["asm"]["dynCall_v"].apply(null, arguments) };
+var dynCall_viif = Module["dynCall_viif"] = function() { return Module["asm"]["dynCall_viif"].apply(null, arguments) };
+var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() { return Module["asm"]["dynCall_viiiiii"].apply(null, arguments) };
+var dynCall_iii = Module["dynCall_iii"] = function() { return Module["asm"]["dynCall_iii"].apply(null, arguments) };
+var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() { return Module["asm"]["dynCall_iiiiii"].apply(null, arguments) };
+var dynCall_viiii = Module["dynCall_viiii"] = function() { return Module["asm"]["dynCall_viiii"].apply(null, arguments) };
+;
+
+Runtime.stackAlloc = Module['stackAlloc'];
+Runtime.stackSave = Module['stackSave'];
+Runtime.stackRestore = Module['stackRestore'];
+Runtime.establishStackSpace = Module['establishStackSpace'];
+
+Runtime.setTempRet0 = Module['setTempRet0'];
+Runtime.getTempRet0 = Module['getTempRet0'];
+
+
+
+// === Auto-generated postamble setup entry stuff ===
+
+Module['asm'] = asm;
+
+
+
+if (memoryInitializer) {
+  if (typeof Module['locateFile'] === 'function') {
+    memoryInitializer = Module['locateFile'](memoryInitializer);
+  } else if (Module['memoryInitializerPrefixURL']) {
+    memoryInitializer = Module['memoryInitializerPrefixURL'] + memoryInitializer;
+  }
+  var data = Module['readBinary'](memoryInitializer);
+  HEAPU8.set(data, Runtime.GLOBAL_BASE);
+}
+
+function ExitStatus(status) {
+  this.name = "ExitStatus";
+  this.message = "Program terminated with exit(" + status + ")";
+  this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+  if (!Module['calledRun']) run();
+  if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+
+  args = args || [];
+
+  ensureInitRuntime();
+
+  var argc = args.length+1;
+  function pad() {
+    for (var i = 0; i < 4-1; i++) {
+      argv.push(0);
+    }
+  }
+  var argv = [allocate(intArrayFromString(Module['thisProgram']), 'i8', ALLOC_NORMAL) ];
+  pad();
+  for (var i = 0; i < argc-1; i = i + 1) {
+    argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+    pad();
+  }
+  argv.push(0);
+  argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+
+  try {
+
+    var ret = Module['_main'](argc, argv, 0);
+
+
+    // if we're not running an evented main loop, it's time to exit
+    exit(ret, /* implicit = */ true);
+  }
+  catch(e) {
+    if (e instanceof ExitStatus) {
+      // exit() throws this once it's done to make sure execution
+      // has been stopped completely
+      return;
+    } else if (e == 'SimulateInfiniteLoop') {
+      // running an evented main loop, don't immediately exit
+      Module['noExitRuntime'] = true;
+      return;
+    } else {
+      if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+      throw e;
+    }
+  } finally {
+    calledMain = true;
+  }
+}
+
+
+
+
+function run(args) {
+  args = args || Module['arguments'];
+
+  if (preloadStartTime === null) preloadStartTime = Date.now();
+
+  if (runDependencies > 0) {
+    return;
+  }
+
+
+  preRun();
+
+  if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+  if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+  function doRun() {
+    if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+    Module['calledRun'] = true;
+
+    if (ABORT) return;
+
+    ensureInitRuntime();
+
+    preMain();
+
+
+    if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
+
+    if (Module['_main'] && shouldRunNow) Module['callMain'](args);
+
+    postRun();
+  }
+
+  if (Module['setStatus']) {
+    Module['setStatus']('Running...');
+    setTimeout(function() {
+      setTimeout(function() {
+        Module['setStatus']('');
+      }, 1);
+      doRun();
+    }, 1);
+  } else {
+    doRun();
+  }
+}
+Module['run'] = Module.run = run;
+
+function exit(status, implicit) {
+  throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+var abortDecorators = [];
+
+function abort(what) {
+  if (what !== undefined) {
+    Module.print(what);
+    Module.printErr(what);
+    what = JSON.stringify(what)
+  } else {
+    what = '';
+  }
+
+  ABORT = true;
+  EXITSTATUS = 1;
+
+  var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';
+
+  var output = 'abort(' + what + ') at ' + stackTrace() + extra;
+  if (abortDecorators) {
+    abortDecorators.forEach(function(decorator) {
+      output = decorator(output, what);
+    });
+  }
+  throw output;
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+  while (Module['preInit'].length > 0) {
+    Module['preInit'].pop()();
+  }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+  shouldRunNow = false;
+}
+
+
+run();
+drainJobQueue();
+
+};  // End of function wrapping the whole top-level Emscripten glue code
+
+const bytecode = os.file.readFile(scriptdir + 'wasm_box2d.wasm', 'binary');
+
+if (typeof setBufferStreamParams == 'function') {
+    setBufferStreamParams(/* delayMillis = */ 1, /* chunkSize = */ 1000);
+}
+const cacheEntry = streamCacheEntry(bytecode);
+
+runBox2d(cacheEntry);
+
+while (!wasmHasTier2CompilationCompleted(cacheEntry.module))
+    sleep(1);
+
+if (wasmCachingEnabled()) {
+    assertEq(cacheEntry.cached, true)
+}
+
+runBox2d(cacheEntry);
+
+if (wasmCachingEnabled()) {
+    runBox2d(wasmCompileInSeparateProcess(bytecode));
+}
diff --git a/js/src/jit-test/tests/wasm/bench/wasm_box2d.wasm b/js/src/jit-test/tests/wasm/bench/wasm_box2d.wasm
new file mode 100644
index 0000000000..bafe75cc82
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bench/wasm_box2d.wasm
diff --git a/js/src/jit-test/tests/wasm/big-resize.js b/js/src/jit-test/tests/wasm/big-resize.js
new file mode 100644
index 0000000000..85b339c3cf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/big-resize.js
@@ -0,0 +1,8 @@
+wasmFullPass(`(module
+    (memory 1 32768)
+    (func $test (result i32)
+        (if (i32.eq (memory.grow (i32.const 16384)) (i32.const -1)) (return (i32.const 42)))
+        (i32.store (i32.const 1073807356) (i32.const 42))
+        (i32.load (i32.const 1073807356)))
+    (export "run" (func $test))
+)`, 42);
diff --git a/js/src/jit-test/tests/wasm/bigint/bigint.js b/js/src/jit-test/tests/wasm/bigint/bigint.js
new file mode 100644
index 0000000000..79e7e416b1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bigint/bigint.js
@@ -0,0 +1,468 @@
+// Used to ensure tests will trigger Wasm Jit stub code.
+var threshold = 2 * getJitCompilerOptions()["ion.warmup.trigger"] + 10;
+function testWithJit(f) {
+  for (var i = 0; i < threshold; i++) {
+    f();
+  }
+}
+
+function testRet() {
+  var f = wasmEvalText(`(module
+    (func (export "f") (result i64) (i64.const 66))
+  )`).exports.f;
+
+  testWithJit(() => {
+    assertEq(typeof f(), "bigint", "should return a bigint");
+    assertEq(f(), 66n, "should return the correct value");
+  });
+}
+
+function testId() {
+  var exports = wasmEvalText(`(module
+    (func (export "f") (param i64 i64) (result i64)
+      (local.get 0)
+    )
+    (func (export "f2") (param i64 i64) (result i64)
+      (local.get 1)
+    )
+  )`).exports;
+  var f = exports.f;
+  var f2 = exports.f2;
+
+  testWithJit(() => {
+    assertEq(f(0n, 1n), 0n);
+    assertEq(f(-0n, 1n), -0n);
+    assertEq(f(123n, 1n), 123n);
+    assertEq(f(-123n, 1n), -123n);
+    assertEq(f(2n ** 63n, 1n), -(2n ** 63n));
+    assertEq(f(2n ** 64n + 123n, 1n), 123n);
+    assertEq(f("5", 1n), 5n);
+    assertEq(f(true, 1n), 1n);
+    assertEq(f(false, 1n), 0n);
+    assertEq(f({ toString() { return "5"; }, }, 1n), 5n);
+    assertEq(f({ valueOf() { return 5n; }, }, 1n), 5n);
+
+    assertEq(f2(1n, 0n), 0n);
+    assertEq(f2(1n, -0n), -0n);
+    assertEq(f2(1n, 123n), 123n);
+    assertEq(f2(1n, -123n), -123n);
+    assertEq(f2(1n, 2n ** 63n), -(2n ** 63n));
+    assertEq(f2(1n, 2n ** 64n + 123n), 123n);
+    assertEq(f2(1n, "5"), 5n);
+    assertEq(f2(1n, true), 1n);
+    assertEq(f2(1n, false), 0n);
+    assertEq(f2(1n, { toString() { return "5"; }, }), 5n);
+    assertEq(f2(1n, { valueOf() { return 5n; }, }), 5n);
+  });
+}
+
+function testNonBigIntArgs() {
+  var f = wasmEvalText(`(module
+    (func (export "f") (param i64) (result i64)
+      (local.get 0)
+    )
+  )`).exports.f;
+
+  assertErrorMessage(() => f(5), TypeError, "can't convert 5 to BigInt");
+  assertErrorMessage(() => f({ valueOf() { return 5; }, }),
+                     TypeError,
+                     "can't convert 5 to BigInt");
+  assertErrorMessage(() => f(5.3), TypeError, "can't convert 5.3 to BigInt");
+  assertErrorMessage(() => f(), TypeError, "can't convert undefined to BigInt");
+  assertErrorMessage(
+    () => f(undefined),
+    TypeError,
+    "can't convert undefined to BigInt"
+  );
+  assertErrorMessage(() => f(null), TypeError, "can't convert null to BigInt");
+  assertErrorMessage(
+    () => f(Symbol("foo")),
+    TypeError,
+    'can\'t convert Symbol("foo") to BigInt'
+  );
+  assertErrorMessage(() => f({}), SyntaxError, "invalid BigInt syntax");
+  assertErrorMessage(() => f({ valueof() { return "foo"; }, }),
+                     SyntaxError,
+                     "invalid BigInt syntax");
+  assertErrorMessage(() => f("x"), SyntaxError, "invalid BigInt syntax");
+}
+
+function testIdPlus() {
+  var f = wasmEvalText(`(module
+    (func (export "f") (param i64) (result i64)
+      (i64.const 8)
+      (get_local 0)
+      (i64.add)
+    )
+  )`).exports.f;
+
+  testWithJit(() => {
+    assertEq(f(0n), 0n + 8n);
+    assertEq(f(147n), 147n + 8n);
+  });
+}
+
+// Test functions with many parameters to stress ABI cases. We want to test
+// spilled arguments both under and over the Ion call inlining limit.
+function testManyArgs() {
+  var f1 = wasmEvalText(`(module
+    (func (export "f")
+      (param i64 i64 i64 i64 i64 i64 i64 i64)
+      (result i64)
+      (get_local 0)
+      (get_local 1)
+      (get_local 2)
+      (get_local 3)
+      (get_local 4)
+      (get_local 5)
+      (get_local 6)
+      (get_local 7)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+    )
+  )`).exports.f;
+
+  var f2 = wasmEvalText(`(module
+    (func (export "f")
+      (param i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+      (result i64)
+      (get_local 0)
+      (get_local 1)
+      (get_local 2)
+      (get_local 3)
+      (get_local 4)
+      (get_local 5)
+      (get_local 6)
+      (get_local 7)
+      (get_local 8)
+      (get_local 9)
+      (get_local 10)
+      (get_local 11)
+      (get_local 12)
+      (get_local 13)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+      (i64.add)
+    )
+  )`).exports.f;
+
+  testWithJit(() => {
+    assertEq(f1(1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n), 8n);
+    assertEq(f2(1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n, 1n), 14n);
+  });
+}
+
+// Test import and re-export.
+function testImportExport() {
+  var f1 = wasmEvalText(
+    `(module
+      (import "i64" "func" (func (param i64)))
+      (export "f" (func 0))
+    )`,
+    {
+      i64: {
+        func(b) {
+          assertEq(b, 42n);
+        },
+      },
+    }
+  ).exports.f;
+
+  var f2 = wasmEvalText(
+    `(module
+      (import "i64" "func" (func (param i64) (result i64)))
+      (export "f" (func 0))
+    )`,
+    {
+      i64: {
+        func(n) {
+          return n + 1n;
+        },
+      },
+    }
+  ).exports.f;
+
+  var f3 = wasmEvalText(
+    `(module
+      (import "" "i64" (func $i64 (param i64) (result i64)))
+      (func (export "f") (param i64) (result i64)
+        (get_local 0)
+        (call $i64))
+    )`,
+    {
+      "": {
+        i64: n => {
+          return n + 1n;
+        },
+      },
+    }
+  ).exports.f;
+
+  var f4 = wasmEvalText(
+    `(module
+      (import "i64" "func" (func (result i64)))
+      (export "f" (func 0))
+    )`,
+    { i64: { func() {} } }
+  ).exports.f;
+
+  testWithJit(() => {
+    assertEq(f1(42n), undefined);
+    assertEq(f2(42n), 43n);
+    assertEq(f3(42n), 43n);
+    assertErrorMessage(() => f4(42), TypeError, "can't convert undefined to BigInt");
+  });
+}
+
+// Test that a mixture of I64 and other argument types works.
+function testMixedArgs() {
+  var f = wasmEvalText(`(module
+    (func (export "f")
+      (param i64 f32 f64 i32 i64)
+      (result i64)
+      (get_local 1)
+      (i64.trunc_s/f32)
+      (get_local 2)
+      (i64.trunc_s/f64)
+      (i64.add)
+      (get_local 3)
+      (i64.extend_i32_u)
+      (i64.add)
+      (get_local 0)
+      (i64.add)
+      (get_local 4)
+      (i64.add)
+    )
+  )`).exports.f;
+
+  testWithJit(() => {
+    assertEq(f(1n, 1.3, 1.7, 1, 1n), 5n);
+  });
+}
+
+function testGlobalImport() {
+  var exports = wasmEvalText(
+    `(module
+      (import "g" "a" (global $a i64))
+      (import "g" "b" (global $b i64))
+      (import "g" "c" (global $c i64))
+
+      (export "a" (global $a))
+      (export "b" (global $b))
+      (export "c" (global $c))
+    )`,
+    { g: { a: 1n, b: 2n ** 63n, c: -100n } }
+  ).exports;
+
+  testWithJit(() => {
+    assertEq(exports.a.value, 1n);
+    assertEq(exports.b.value, -(2n ** 63n));
+    assertEq(exports.c.value, -100n);
+  });
+}
+
+function testMutableGlobalImport() {
+  var exports = wasmEvalText(
+    `(module
+      (import "g" "a" (global $a (mut i64)))
+      (import "g" "b" (global $b (mut i64)))
+
+      (export "a" (global $a))
+      (export "b" (global $b))
+    )`,
+    {
+      g: {
+        a: new WebAssembly.Global({ value: "i64", mutable: true }, 1n),
+        b: new WebAssembly.Global({ value: "i64", mutable: true }, "2"),
+      },
+    }
+  ).exports;
+
+  testWithJit(() => {
+    assertEq(exports.a.value, 1n);
+    assertEq(exports.b.value, 2n);
+  });
+}
+
+function testMutableGlobalImportLiteral() {
+  assertErrorMessage(
+    () =>
+      wasmEvalText(
+        `(module
+          (import "g" "a" (global $a (mut i64)))
+        )`,
+        { g: { a: 1n } }
+      ),
+    WebAssembly.LinkError,
+    "imported global mutability mismatch"
+  );
+}
+
+function testGlobalBadImportLiteral() {
+  assertErrorMessage(
+    () =>
+      wasmEvalText(
+        `(module
+          (import "g" "a" (global $a i64))
+          (export "a" (global $a))
+        )`,
+        { g: { a: 1 } }
+      ),
+    WebAssembly.LinkError,
+    "import object field 'a' is not a BigInt"
+  );
+
+  assertErrorMessage(
+    () =>
+      wasmEvalText(
+        `(module
+          (import "g" "a" (global $a i64))
+          (export "a" (global $a))
+        )`,
+        { g: { a: "foo" } }
+      ),
+    WebAssembly.LinkError,
+    "import object field 'a' is not a BigInt"
+  );
+}
+
+// This exercises error code paths that were added due to BigInt/I64
+// conversion, though the test does not directly deal with I64 types.
+function testGlobalBadImportNumber() {
+  assertErrorMessage(
+    () =>
+      wasmEvalText(
+        `(module
+          (import "g" "a" (global $a i32))
+          (export "a" (global $a))
+        )`,
+        { g: { a: 1n } }
+      ),
+    WebAssembly.LinkError,
+    "import object field 'a' is not a Number"
+  );
+
+  assertErrorMessage(
+    () =>
+      wasmEvalText(
+        `(module
+          (import "g" "a" (global $a i32))
+          (export "a" (global $a))
+        )`,
+        { g: { a: "foo" } }
+      ),
+    WebAssembly.LinkError,
+    "import object field 'a' is not a Number"
+  );
+}
+
+function testI64Global() {
+  var global = new WebAssembly.Global({ value: "i64", mutable: true });
+
+  assertEq(global.value, 0n); // initial value
+
+  global.value = 123n;
+  assertEq(global.value, 123n);
+
+  global.value = 2n ** 63n;
+  assertEq(global.value, -(2n ** 63n));
+
+  global.value = "123";
+  assertEq(global.value, 123n);
+}
+
+function testI64GlobalValueOf() {
+  var argument = { value: "i64" };
+
+  // as literal
+  var global = new WebAssembly.Global(argument, {
+    valueOf() {
+      return 123n;
+    },
+  });
+  assertEq(global.value, 123n);
+
+  // as string
+  var global2 = new WebAssembly.Global(argument, {
+    valueOf() {
+      return "123";
+    },
+  });
+  assertEq(global.value, 123n);
+}
+
+function testGlobalI64ValueWrongType() {
+  var argument = { value: "i64" };
+  assertErrorMessage(
+    () => new WebAssembly.Global(argument, 666),
+    TypeError,
+    "can't convert 666 to BigInt"
+  );
+  assertErrorMessage(
+    () => new WebAssembly.Global(argument, "foo"),
+    SyntaxError,
+    "invalid BigInt syntax"
+  );
+  assertErrorMessage(
+    () =>
+      new WebAssembly.Global(argument, {
+        valueOf() {
+          return 5;
+        },
+      }),
+    TypeError,
+    "can't convert 5 to BigInt"
+  );
+}
+
+function testGlobalI64SetWrongType() {
+  var global = new WebAssembly.Global({ value: "i64", mutable: true });
+  assertErrorMessage(() => (global.value = 1), TypeError, "can't convert 1 to BigInt");
+  assertErrorMessage(
+    () => (global.value = "foo"),
+    SyntaxError,
+    "invalid BigInt syntax"
+  );
+  assertErrorMessage(
+    () =>
+      (global.value = {
+        valueOf() {
+          return 5;
+        },
+      }),
+    TypeError,
+    "can't convert 5 to BigInt"
+  );
+}
+
+testRet();
+testId();
+testIdPlus();
+testNonBigIntArgs();
+testManyArgs();
+testImportExport();
+testMixedArgs();
+testGlobalImport();
+testMutableGlobalImport();
+testMutableGlobalImportLiteral();
+testGlobalBadImportLiteral();
+testGlobalBadImportNumber();
+testI64Global();
+testI64GlobalValueOf();
+testGlobalI64ValueWrongType();
+testGlobalI64SetWrongType();
diff --git a/js/src/jit-test/tests/wasm/bigint/bug1633740.js b/js/src/jit-test/tests/wasm/bigint/bug1633740.js
new file mode 100644
index 0000000000..773e8932d9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bigint/bug1633740.js
@@ -0,0 +1,25 @@
+// Test for bug 1633740, an intermittent GC-related crash caused by
+// the bigint/i64 conversion in inlined Ion to Wasm calls.
+
+// Used to help ensure this will trigger the Ion inlined call path.
+var threshold = 2 * getJitCompilerOptions()["ion.warmup.trigger"] + 10;
+function testWithJit(f) {
+  for (var i = 0; i < threshold; i++) {
+    f();
+  }
+}
+
+function test() {
+  var exports = wasmEvalText(`(module
+    (func (export "f") (param i64) (result i64)
+      (local.get 0)
+    ))`).exports;
+  var f = exports.f;
+
+  testWithJit(() => {
+    assertEq(f("5"), 5n);
+  });
+}
+
+gczeal(7, 1); // Collect nursery on every allocation.
+test();
diff --git a/js/src/jit-test/tests/wasm/bigint/directives.txt b/js/src/jit-test/tests/wasm/bigint/directives.txt
new file mode 100644
index 0000000000..6fb4fc4a49
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bigint/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/bigint/stubs.js b/js/src/jit-test/tests/wasm/bigint/stubs.js
new file mode 100644
index 0000000000..89f7d78413
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bigint/stubs.js
@@ -0,0 +1,142 @@
+// This is similar to the corresponding JIT exit stub test in the
+// wasm/import-export.js file, but it also tests BigInt cases.
+(function testImportJitExit() {
+  let options = getJitCompilerOptions();
+  if (!options["baseline.enable"]) return;
+
+  let baselineTrigger = options["baseline.warmup.trigger"];
+
+  let valueToConvert = 0;
+  function ffi(n) {
+    if (n == 1337n) {
+      return BigInt(valueToConvert);
+    }
+    return 42n;
+  }
+
+  // This case is intended to test that the I64 to BigInt argument
+  // filling for the JIT exit stub does not interfere with the other
+  // argument registers. It's important that the BigInt argument comes
+  // first (to test that it doesn't clobber the subsequent ones).
+  function ffi2(n, x1, x2, x3, x4, x5, x6) {
+    return (
+      42n +
+      BigInt(x1) +
+      BigInt(x2) +
+      BigInt(x3) +
+      BigInt(x4) +
+      BigInt(x5) +
+      BigInt(x6)
+    );
+  }
+
+  // This case is for testing issues with potential GC.
+  function ffi3(n1, n2, n3, n4) {
+    return n3;
+  }
+
+  // Baseline compile ffis.
+  for (let i = baselineTrigger + 1; i-- > 0; ) {
+    ffi(BigInt(i));
+    ffi2(BigInt(i), i, i, i, i, i, i);
+    ffi3(BigInt(i), BigInt(i), BigInt(i), BigInt(i));
+  }
+
+  let imports = {
+    a: {
+      ffi,
+      ffi2,
+      ffi3,
+    },
+  };
+
+  ex = wasmEvalText(
+    `(module
+        (import "a" "ffi" (func $ffi (param i64) (result i64)))
+        (import "a" "ffi2" (func $ffi2
+          (param i64 i32 i32 i32 i32 i32 i32)
+          (result i64)))
+        (import "a" "ffi3" (func $ffi3 (param i64 i64 i64 i64) (result i64)))
+
+        (func (export "callffi") (param i64) (result i64)
+         local.get 0
+         call $ffi
+        )
+
+        (func (export "callffi2") (param i32 i64) (result i64)
+         local.get 1
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         call $ffi2
+        )
+
+        (func (export "callffi3") (param i64 i64 i64 i64) (result i64)
+          local.get 0
+          local.get 1
+          local.get 2
+          local.get 3
+          call $ffi3
+        )
+    )`,
+    imports
+  ).exports;
+
+  // Enable the jit exit for each JS callee.
+  assertEq(ex.callffi(0n), 42n);
+  assertEq(ex.callffi2(2, 0n), 54n);
+  assertEq(ex.callffi3(0n, 1n, 2n, 3n), 2n);
+
+  // Test the jit exit under normal conditions.
+  assertEq(ex.callffi(0n), 42n);
+  assertEq(ex.callffi(1337n), 0n);
+  assertEq(ex.callffi2(2, 0n), 54n);
+  assertEq(ex.callffi3(0n, 1n, 2n, 3n), 2n);
+
+  // Test the jit exit with GC stress in order to ensure that
+  // any trigger of GC in the stub do not cause errors.
+  if (this.gczeal) {
+    this.gczeal(2, 1); // Collect on every allocation
+  }
+  for (let i = 0; i < 1000; i++) {
+    assertEq(ex.callffi3(0n, 1n, 2n, 3n), 2n);
+  }
+})();
+
+// Test JIT entry stub
+(function testJitEntry() {
+  let options = getJitCompilerOptions();
+  if (!options["baseline.enable"]) return;
+
+  let baselineTrigger = options["baseline.warmup.trigger"];
+
+  i = wasmEvalText(
+    `(module
+      (func (export "foo") (param i64) (result i64)
+       local.get 0
+       i64.const 1
+       i64.add
+       return
+      )
+  )`,
+    {}
+  ).exports;
+
+  function caller(n) {
+    return i.foo(42n);
+  }
+
+  // Baseline compile ffis.
+  for (let i = baselineTrigger + 1; i-- > 0; ) {
+    caller(i);
+  }
+
+  // Enable the jit entry.
+  assertEq(caller(0), 43n);
+
+  // Test the jit exit under normal conditions.
+  assertEq(caller(0), 43n);
+})();
diff --git a/js/src/jit-test/tests/wasm/binary-slow.js b/js/src/jit-test/tests/wasm/binary-slow.js
new file mode 100644
index 0000000000..0bff1bda0b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/binary-slow.js
@@ -0,0 +1,20 @@
+load(libdir + "wasm-binary.js");
+
+const wasmEval = (code, imports) => new WebAssembly.Instance(new WebAssembly.Module(code), imports).exports;
+const v2vSig = {args:[], ret:VoidCode};
+const v2vSigSection = sigSection([v2vSig]);
+
+// Deep nesting shouldn't crash or even throw. This test takes a long time to
+// run with the JITs disabled, so to avoid occasional timeout, disable. Also
+// in eager mode, this triggers pathological recompilation, so only run for
+// "normal" JIT modes. This test is totally independent of the JITs so this
+// shouldn't matter.
+var jco = getJitCompilerOptions();
+if (jco["ion.enable"] && jco["baseline.enable"] && jco["baseline.warmup.trigger"] > 0 && jco["ion.warmup.trigger"] > 10) {
+    var manyBlocks = [];
+    for (var i = 0; i < 20000; i++)
+        manyBlocks.push(BlockCode, VoidCode);
+    for (var i = 0; i < 20000; i++)
+        manyBlocks.push(EndCode);
+    wasmEval(moduleWithSections([v2vSigSection, declSection([0]), bodySection([funcBody({locals:[], body:manyBlocks})])]));
+}
diff --git a/js/src/jit-test/tests/wasm/binary.js b/js/src/jit-test/tests/wasm/binary.js
new file mode 100644
index 0000000000..232d22e9bf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/binary.js
@@ -0,0 +1,404 @@
+load(libdir + "wasm-binary.js");
+
+const { extractStackFrameFunction } = WasmHelpers;
+
+const { Module, RuntimeError, CompileError } = WebAssembly;
+
+const magicError = /failed to match magic number/;
+const unknownSection = /expected custom section/;
+
+function sectionError(section) {
+    return RegExp(`failed to start ${section} section`);
+}
+
+function versionError(actual) {
+    var expect = encodingVersion;
+    var str = `binary version 0x${actual.toString(16)} does not match expected version 0x${expect.toString(16)}`;
+    return RegExp(str);
+}
+
+const U32MAX_LEB = [255, 255, 255, 255, 15];
+
+const wasmEval = (code, imports) => new WebAssembly.Instance(new Module(code), imports).exports;
+
+assertErrorMessage(() => wasmEval(toU8([])), CompileError, magicError);
+assertErrorMessage(() => wasmEval(toU8([42])), CompileError, magicError);
+assertErrorMessage(() => wasmEval(toU8([magic0, magic1, magic2])), CompileError, magicError);
+assertErrorMessage(() => wasmEval(toU8([1,2,3,4])), CompileError, magicError);
+assertErrorMessage(() => wasmEval(toU8([magic0, magic1, magic2, magic3])), CompileError, versionError(0x6d736100));
+assertErrorMessage(() => wasmEval(toU8([magic0, magic1, magic2, magic3, 1])), CompileError, versionError(0x6d736100));
+assertErrorMessage(() => wasmEval(toU8([magic0, magic1, magic2, magic3, ver0])), CompileError, versionError(0x6d736100));
+assertErrorMessage(() => wasmEval(toU8([magic0, magic1, magic2, magic3, ver0, ver1, ver2])), CompileError, versionError(0x6d736100));
+
+var o = wasmEval(toU8(moduleHeaderThen()));
+assertEq(Object.getOwnPropertyNames(o).length, 0);
+
+// unfinished known sections
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(typeId))), CompileError, sectionError("type"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(importId))), CompileError, sectionError("import"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(functionId))), CompileError, sectionError("function"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(tableId))), CompileError, sectionError("table"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(memoryId))), CompileError, sectionError("memory"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(globalId))), CompileError, sectionError("global"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(exportId))), CompileError, sectionError("export"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(startId))), CompileError, sectionError("start"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(elemId))), CompileError, sectionError("elem"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(codeId))), CompileError, sectionError("code"));
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(dataId))), CompileError, sectionError("data"));
+
+// unknown sections are unconditionally rejected
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(37))), CompileError, unknownSection);
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(37, 0))), CompileError, unknownSection);
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(37, 1, 0))), CompileError, unknownSection);
+
+// user sections have special rules
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(0))), CompileError, sectionError("custom"));  // no length
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(0, 0))), CompileError, sectionError("custom"));  // no id
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(0, 0, 0))), CompileError, sectionError("custom"));  // payload too small to have id length
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(0, 1, 1))), CompileError, sectionError("custom"));  // id not present
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(0, 1, 1, 65))), CompileError, sectionError("custom"));  // id length doesn't fit in section
+assertErrorMessage(() => wasmEval(toU8(moduleHeaderThen(0, 1, 0, 0))), CompileError, sectionError("custom"));  // second, unfinished custom section
+wasmEval(toU8(moduleHeaderThen(0, 1, 0)));  // empty id
+wasmEval(toU8(moduleHeaderThen(0, 1, 0,  0, 1, 0)));  // 2x empty id
+wasmEval(toU8(moduleHeaderThen(0, 2, 1, 65)));  // id = "A"
+
+const v2vSig = {args:[], ret:VoidCode};
+const v2vSigSection = sigSection([v2vSig]);
+const i2vSig = {args:[I32Code], ret:VoidCode};
+const v2vBody = funcBody({locals:[], body:[]});
+
+assertErrorMessage(() => wasmEval(moduleWithSections([ {name: typeId, body: U32MAX_LEB } ])), CompileError, /too many types/);
+assertErrorMessage(() => wasmEval(moduleWithSections([ {name: typeId, body: [1, 0], } ])), CompileError, /expected type form/);
+assertErrorMessage(() => wasmEval(moduleWithSections([ {name: typeId, body: [1, FuncCode, ...U32MAX_LEB], } ])), CompileError, /too many arguments in signature/);
+
+assertThrowsInstanceOf(() => wasmEval(moduleWithSections([{name: typeId, body: [1]}])), CompileError);
+assertThrowsInstanceOf(() => wasmEval(moduleWithSections([{name: typeId, body: [1, 1, 0]}])), CompileError);
+
+wasmEval(moduleWithSections([sigSection([])]));
+wasmEval(moduleWithSections([v2vSigSection]));
+wasmEval(moduleWithSections([sigSection([i2vSig])]));
+wasmEval(moduleWithSections([sigSection([v2vSig, i2vSig])]));
+
+assertErrorMessage(() => wasmEval(moduleWithSections([sigSection([{args:[], ret:100}])])), CompileError, /bad type/);
+assertErrorMessage(() => wasmEval(moduleWithSections([sigSection([{args:[100], ret:VoidCode}])])), CompileError, /bad type/);
+
+assertThrowsInstanceOf(() => wasmEval(moduleWithSections([sigSection([]), declSection([0])])), CompileError, /signature index out of range/);
+assertThrowsInstanceOf(() => wasmEval(moduleWithSections([v2vSigSection, declSection([1])])), CompileError, /signature index out of range/);
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, declSection([0])])), CompileError, /expected code section/);
+wasmEval(moduleWithSections([v2vSigSection, declSection([0]), bodySection([v2vBody])]));
+
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, declSection([0]), bodySection([v2vBody.concat(v2vBody)])])), CompileError, /byte size mismatch in code section/);
+
+assertThrowsInstanceOf(() => wasmEval(moduleWithSections([v2vSigSection, {name: importId, body:[]}])), CompileError);
+assertErrorMessage(() => wasmEval(moduleWithSections([importSection([{sigIndex:0, module:"a", func:"b"}])])), CompileError, /signature index out of range/);
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, importSection([{sigIndex:1, module:"a", func:"b"}])])), CompileError, /signature index out of range/);
+wasmEval(moduleWithSections([v2vSigSection, importSection([])]));
+wasmEval(moduleWithSections([v2vSigSection, importSection([{sigIndex:0, module:"a", func:""}])]), {a:{"":()=>{}}});
+
+wasmEval(moduleWithSections([
+    v2vSigSection,
+    importSection([{sigIndex:0, module:"a", func:""}]),
+    declSection([0]),
+    bodySection([v2vBody])
+]), {a:{"":()=>{}}});
+
+assertErrorMessage(() => wasmEval(moduleWithSections([ dataSection([{offset:1, elems:[]}]) ])), CompileError, /data segment requires a memory section/);
+
+wasmEval(moduleWithSections([tableSection(0)]));
+wasmEval(moduleWithSections([elemSection([])]));
+wasmEval(moduleWithSections([tableSection(0), elemSection([])]));
+wasmEval(moduleWithSections([tableSection(1), elemSection([{offset:1, elems:[]}])]));
+assertErrorMessage(() => wasmEval(moduleWithSections([tableSection(1), elemSection([{offset:0, elems:[0]}])])), CompileError, /table element out of range/);
+wasmEval(moduleWithSections([v2vSigSection, declSection([0]), tableSection(1), elemSection([{offset:0, elems:[0]}]), bodySection([v2vBody])]));
+wasmEval(moduleWithSections([v2vSigSection, declSection([0]), tableSection(2), elemSection([{offset:0, elems:[0,0]}]), bodySection([v2vBody])]));
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, declSection([0]), tableSection(2), elemSection([{offset:0, elems:[0,1]}]), bodySection([v2vBody])])), CompileError, /table element out of range/);
+wasmEval(moduleWithSections([v2vSigSection, declSection([0,0,0]), tableSection(4), elemSection([{offset:0, elems:[0,1,0,2]}]), bodySection([v2vBody, v2vBody, v2vBody])]));
+wasmEval(moduleWithSections([sigSection([v2vSig,i2vSig]), declSection([0,0,1]), tableSection(3), elemSection([{offset:0,elems:[0,1,2]}]), bodySection([v2vBody, v2vBody, v2vBody])]));
+
+wasmEval(moduleWithSections([tableSection0()]));
+
+wasmEval(moduleWithSections([memorySection(0)]));
+
+function invalidMemorySection2() {
+    var body = [];
+    body.push(...varU32(2));           // number of memories
+    body.push(...varU32(0x0));
+    body.push(...varU32(0));
+    body.push(...varU32(0x0));
+    body.push(...varU32(0));
+    return { name: memoryId, body };
+}
+
+wasmEval(moduleWithSections([memorySection0()]));
+assertErrorMessage(() => wasmEval(moduleWithSections([invalidMemorySection2()])), CompileError, /number of memories must be at most one/);
+
+// Test early 'end'
+const bodyMismatch = /(function body length mismatch)|(operators remaining after end of function)/;
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, declSection([0]), bodySection([funcBody({locals:[], body:[EndCode]})])])), CompileError, bodyMismatch);
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, declSection([0]), bodySection([funcBody({locals:[], body:[UnreachableCode,EndCode]})])])), CompileError, bodyMismatch);
+assertErrorMessage(() => wasmEval(moduleWithSections([v2vSigSection, declSection([0]), bodySection([funcBody({locals:[], body:[EndCode,UnreachableCode]})])])), CompileError, bodyMismatch);
+
+// Ignore errors in name section.
+var tooBigNameSection = {
+    name: userDefinedId,
+    body: [...string(nameName), ...varU32(Math.pow(2, 31))] // declare 2**31 functions.
+};
+wasmEval(moduleWithSections([tooBigNameSection]));
+
+// Skip custom sections before any expected section
+var customDefSec = customSection("wee", 42, 13);
+var declSec = declSection([0]);
+var bodySec = bodySection([v2vBody]);
+var nameSec = nameSection([funcNameSubsection([{name:'hi'}])]);
+wasmEval(moduleWithSections([customDefSec, v2vSigSection, declSec, bodySec]));
+wasmEval(moduleWithSections([v2vSigSection, customDefSec, declSec, bodySec]));
+wasmEval(moduleWithSections([v2vSigSection, declSec, customDefSec, bodySec]));
+wasmEval(moduleWithSections([v2vSigSection, declSec, bodySec, customDefSec]));
+wasmEval(moduleWithSections([customDefSec, customDefSec, v2vSigSection, declSec, bodySec]));
+wasmEval(moduleWithSections([customDefSec, customDefSec, v2vSigSection, customDefSec, declSec, customDefSec, bodySec]));
+
+// custom sections reflection:
+function checkCustomSection(buf, val) {
+    assertEq(buf instanceof ArrayBuffer, true);
+    assertEq(buf.byteLength, 1);
+    assertEq(new Uint8Array(buf)[0], val);
+}
+var custom1 = customSection("one", 1);
+var custom2 = customSection("one", 2);
+var custom3 = customSection("two", 3);
+var custom4 = customSection("three", 4);
+var custom5 = customSection("three", 5);
+var custom6 = customSection("three", 6);
+var m = new Module(moduleWithSections([custom1, v2vSigSection, custom2, declSec, custom3, bodySec, custom4, nameSec, custom5, custom6]));
+var arr = Module.customSections(m, "one");
+assertEq(arr.length, 2);
+checkCustomSection(arr[0], 1);
+checkCustomSection(arr[1], 2);
+var arr = Module.customSections(m, "two");
+assertEq(arr.length, 1);
+checkCustomSection(arr[0], 3);
+var arr = Module.customSections(m, "three");
+assertEq(arr.length, 3);
+checkCustomSection(arr[0], 4);
+checkCustomSection(arr[1], 5);
+checkCustomSection(arr[2], 6);
+var arr = Module.customSections(m, "name");
+assertEq(arr.length, 1);
+assertEq(arr[0].byteLength, nameSec.body.length - 5 /* 4name */);
+
+// Test name/custom section warnings:
+const nameWarning = /validated with warning.*'name' custom section/;
+const okNameSec = nameSection([]);
+assertNoWarning(() => wasmEval(moduleWithSections([v2vSigSection, declSec, bodySec, okNameSec])));
+const badNameSec1 = nameSection([]);
+badNameSec1.body.push(1);
+assertWarning(() => wasmEval(moduleWithSections([v2vSigSection, declSec, bodySec, badNameSec1])), nameWarning);
+const badNameSec2 = nameSection([funcNameSubsection([{name:'blah'}])]);
+badNameSec2.body.push(100, 20, 42, 83);
+assertWarning(() => wasmEval(moduleWithSections([v2vSigSection, declSec, bodySec, badNameSec2])), nameWarning);
+const badNameSec3 = nameSection([funcNameSubsection([{name:'blah'}])]);
+badNameSec3.body.pop();
+assertWarning(() => wasmEval(moduleWithSections([v2vSigSection, declSec, bodySec, badNameSec3])), nameWarning);
+assertNoWarning(() => wasmEval(moduleWithSections([nameSection([moduleNameSubsection('hi')])])));
+assertWarning(() => wasmEval(moduleWithSections([nameSection([moduleNameSubsection('hi'), moduleNameSubsection('boo')])])), nameWarning);
+// Unknown name subsection
+assertNoWarning(() => wasmEval(moduleWithSections([nameSection([moduleNameSubsection('hi'), [4, 0]])])));
+assertWarning(() => wasmEval(moduleWithSections([nameSection([moduleNameSubsection('hi'), [4, 1]])])), nameWarning);
+assertNoWarning(() => wasmEval(moduleWithSections([nameSection([moduleNameSubsection('hi'), [4, 1, 42]])])));
+
+// Provide a module name but no function names.
+assertErrorMessage(() => wasmEval(moduleWithSections([
+    v2vSigSection,
+    declSection([0]),
+    exportSection([{funcIndex: 0, name: "f"}]),
+    bodySection([funcBody({locals:[], body:[UnreachableCode]})]),
+    nameSection([moduleNameSubsection('hi')])])
+).f(), RuntimeError, /unreachable/);
+
+// Diagnose invalid block signature types.
+for (var bad of [0xff, 1, 0x3f])
+    assertErrorMessage(() => wasmEval(moduleWithSections([sigSection([v2vSig]), declSection([0]), bodySection([funcBody({locals:[], body:[BlockCode, bad, EndCode]})])])), CompileError, /(invalid .*block type)|(unknown type)/);
+
+const multiValueModule = moduleWithSections([sigSection([v2vSig]), declSection([0]), bodySection([funcBody({locals:[], body:[BlockCode, 0, EndCode]})])]);
+// In this test module, 0 denotes a void-to-void block type.
+assertEq(WebAssembly.validate(multiValueModule), true);
+
+// Ensure all invalid opcodes are rejected.  Note that the game here (and for
+// the prefixed cases below) is to present only opcodes which will be rejected by
+// *both* Baseline and Ion.
+for (let op of undefinedOpcodes) {
+    let binary = moduleWithSections([v2vSigSection, declSection([0]), bodySection([funcBody({locals:[], body:[op]})])]);
+    assertErrorMessage(() => wasmEval(binary), CompileError, /((unrecognized|Unknown) opcode)|(tail calls support is not enabled)|(Exceptions support is not enabled)|(Unexpected EOF)/);
+    assertEq(WebAssembly.validate(binary), false);
+}
+
+// Prefixed opcodes
+
+function checkIllegalPrefixed(prefix, opcode) {
+    let binary = moduleWithSections([v2vSigSection,
+                                     declSection([0]),
+                                     bodySection([funcBody({locals:[],
+                                                            body:[prefix, ...varU32(opcode)]})])]);
+    assertErrorMessage(() => wasmEval(binary), CompileError, /((unrecognized|Unknown) opcode)|(Unknown.*subopcode)|(Unexpected EOF)|(SIMD support is not enabled)|(invalid lane index)/);
+    assertEq(WebAssembly.validate(binary), false);
+}
+
+// Illegal GcPrefix opcodes
+
+let reservedGc = {};
+if (wasmGcEnabled()) {
+    reservedGc = {
+      // Structure operations
+      0x07: true, 0x08: true, 0x03: true, 0x04: true, 0x05: true, 0x06: true,
+      // Array operations
+      0x1b: true, 0x1a: true, 0x1c: true, 0x1d: true, 0x10: true, 0x13: true,
+      0x14: true, 0x15: true, 0x16: true, 0x17: true, 0x18: true,
+      // Ref operations
+      0x44: true, 0x45: true, 0x46: true, 0x47: true,
+    };
+}
+for (let i = 0; i < 256; i++) {
+    if (reservedGc.hasOwnProperty(i)) {
+        continue;
+    }
+    checkIllegalPrefixed(GcPrefix, i);
+}
+
+// Illegal ThreadPrefix opcodes
+//
+// June 2017 threads draft:
+//
+//  0x00 .. 0x03 are wait/wake/fence ops
+//  0x10 .. 0x4f are primitive atomic ops
+
+for (let i = 0x4; i < 0x10; i++)
+    checkIllegalPrefixed(ThreadPrefix, i);
+
+for (let i = 0x4f; i < 0x100; i++)
+    checkIllegalPrefixed(ThreadPrefix, i);
+
+// Illegal Misc opcodes
+
+var reservedMisc =
+    { // Saturating conversions (standardized)
+      0x00: true, 0x01: true, 0x02: true, 0x03: true, 0x04: true, 0x05: true, 0x06: true, 0x07: true,
+      // Bulk memory (proposed)
+      0x08: true, 0x09: true, 0x0a: true, 0x0b: true, 0x0c: true, 0x0d: true, 0x0e: true,
+      // Table (proposed)
+      0x0f: true, 0x10: true, 0x11: true, 0x12: true,
+      // Structure operations (experimental, internal)
+      0x50: true, 0x51: true, 0x52: true, 0x53: true };
+
+for (let i = 0; i < 256; i++) {
+    if (reservedMisc.hasOwnProperty(i))
+        continue;
+    checkIllegalPrefixed(MiscPrefix, i);
+}
+
+// Illegal SIMD opcodes - the upper bound is actually very large, not much to be
+// done about that.
+
+if (!wasmSimdEnabled()) {
+    for (let i = 0; i < 0x130; i++) {
+        checkIllegalPrefixed(SimdPrefix, i);
+    }
+} else {
+    let reservedSimd = [
+        0x9a, 0xa2, 0xa5, 0xa6, 0xaf, 0xb0, 0xb2, 0xb3, 0xb4, 0xbb,
+        0xc2, 0xc5, 0xc6, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4, 0xe2, 0xee,
+        0x115, 0x116, 0x117,
+        0x118, 0x119, 0x11a, 0x11b, 0x11c, 0x11d, 0x11e, 0x11f,
+        0x120, 0x121, 0x122, 0x123, 0x124, 0x125, 0x126, 0x127,
+        0x128, 0x129, 0x12a, 0x12b, 0x12c, 0x12d, 0x12e, 0x12f,
+    ];
+    for (let i of reservedSimd) {
+        checkIllegalPrefixed(SimdPrefix, i);
+    }
+}
+
+// Illegal MozPrefix opcodes (all of them)
+for (let i = 0; i < 256; i++)
+    checkIllegalPrefixed(MozPrefix, i);
+
+for (let prefix of [ThreadPrefix, MiscPrefix, SimdPrefix, MozPrefix]) {
+    // Prefix without a subsequent opcode.  We must ask funcBody not to add an
+    // End code after the prefix, so the body really is just the prefix byte.
+    let binary = moduleWithSections([v2vSigSection, declSection([0]), bodySection([funcBody({locals:[], body:[prefix]}, /*withEndCode=*/false)])]);
+    assertErrorMessage(() => wasmEval(binary), CompileError, /(unable to read opcode)|(Unexpected EOF)|(Unknown opcode)/);
+    assertEq(WebAssembly.validate(binary), false);
+}
+
+// Checking stack trace.
+function runStackTraceTest(moduleName, funcNames, expectedName) {
+    var sections = [
+        sigSection([v2vSig]),
+        importSection([{sigIndex:0, module:"env", func:"callback"}]),
+        declSection([0]),
+        exportSection([{funcIndex:1, name: "run"}]),
+        bodySection([funcBody({locals: [], body: [CallCode, varU32(0)]})]),
+        customSection("whoa"),
+        customSection("wee", 42),
+    ];
+    if (moduleName || funcNames) {
+        var subsections = [];
+        if (moduleName)
+            subsections.push(moduleNameSubsection(moduleName));
+        if (funcNames)
+            subsections.push(funcNameSubsection(funcNames));
+        sections.push(nameSection(subsections));
+    }
+    sections.push(customSection("yay", 13));
+
+    var result = "";
+    var callback = () => {
+        result = extractStackFrameFunction(new Error().stack.split('\n')[1]);
+    };
+    wasmEval(moduleWithSections(sections), {"env": { callback }}).run();
+    assertEq(result, expectedName);
+};
+
+runStackTraceTest(null, null, 'wasm-function[1]');
+runStackTraceTest(null, [{name:'blah'}, {name:'test'}], 'test');
+runStackTraceTest(null, [{name:'test', index:1}], 'test');
+runStackTraceTest(null, [{name:'blah'}, {name:'test', locals: [{name: 'var1'}, {name: 'var2'}]}], 'test');
+runStackTraceTest(null, [{name:'blah'}, {name:'test', locals: [{name: 'var1'}, {name: 'var2'}]}], 'test');
+runStackTraceTest(null, [{name:'blah'}, {name:'test1'}], 'test1');
+runStackTraceTest(null, [{name:'blah'}, {name:'test☃'}], 'test☃');
+runStackTraceTest(null, [{name:'blah'}, {name:'te\xE0\xFF'}], 'te\xE0\xFF');
+runStackTraceTest(null, [{name:'blah'}], 'wasm-function[1]');
+runStackTraceTest(null, [], 'wasm-function[1]');
+runStackTraceTest("", [{name:'blah'}, {name:'test'}], 'test');
+runStackTraceTest("a", [{name:'blah'}, {name:'test'}], 'a.test');
+// Notice that invalid names section content shall not fail the parsing
+runStackTraceTest(null, [{name:'blah'}, {name:'test', index: 2}], 'wasm-function[1]'); // invalid index
+runStackTraceTest(null, [{name:'blah'}, {name:'test', index: 100000}], 'wasm-function[1]'); // invalid index
+runStackTraceTest(null, [{name:'blah'}, {name:'test', nameLen: 100}], 'wasm-function[1]'); // invalid name size
+runStackTraceTest(null, [{name:'blah'}, {name:''}], 'wasm-function[1]'); // empty name
+
+// Enable and disable Gecko profiling mode, to ensure all live instances
+// names won't make us crash.
+enableGeckoProfiling();
+disableGeckoProfiling();
+
+function testValidNameSectionWithProfiling() {
+    enableGeckoProfiling();
+    wasmEval(moduleWithSections([v2vSigSection, declSec, bodySec, nameSec]));
+    disableGeckoProfiling();
+}
+testValidNameSectionWithProfiling();
+
+// Memory alignment can use non-minimal LEB128
+wasmEval(moduleWithSections([
+    v2vSigSection,
+    declSection([0]),
+    memorySection(0),
+    bodySection([
+        funcBody({locals: [], body: [
+            I32ConstCode, 0x00, // i32.const 0
+            I32Load,
+                0x81, 0x00, // alignment 1, non-minimal
+                0x00, // offset 0
+            DropCode,
+        ]}),
+    ]),
+]));
diff --git a/js/src/jit-test/tests/wasm/binop-arm64-ion-codegen.js b/js/src/jit-test/tests/wasm/binop-arm64-ion-codegen.js
new file mode 100644
index 0000000000..8636c30804
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/binop-arm64-ion-codegen.js
@@ -0,0 +1,407 @@
+// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().arm64; include:codegen-arm64-test.js
+
+// Basic constant folding tests
+
+for ( [op, lhs, rhs, expect] of
+      [['add',   5,    8,    'd28001a0  mov     x0, #0xd'],
+       ['sub',   4,    5,    '92800000  mov     x0, #0xffffffffffffffff'],
+       ['mul',   8,    3,    'd2800300  mov     x0, #0x18'],
+       ['div_s', -8,   3,    '92800020  mov     x0, #0xfffffffffffffffe'],
+       ['div_u', 8,    3,    'd2800040  mov     x0, #0x2'],
+       ['rem_s', 8,    5,    'd2800060  mov     x0, #0x3'],
+       ['rem_u', -7,   4,    'd2800020  mov     x0, #0x1'],
+       ['and',   0xfe, 0x77, 'd2800ec0  mov     x0, #0x76'],
+       ['or',    0xfe, 0x77, 'd2801fe0  mov     x0, #0xff'],
+       ['xor',   0xfe, 0x77, 'd2801120  mov     x0, #0x89'],
+       ['shl',   3,    4,    'd2800600  mov     x0, #0x30'],
+       ['shr_s', -8,   1,    '92800060  mov     x0, #0xfffffffffffffffc'],
+       ['shr_u', -8,   1,    'b27ef3e0  mov     x0, #0x7ffffffffffffffc']] ) {
+    codegenTestARM64_adhoc(`
+(module
+  (func (export "f") (result i64)
+    (i64.${op} (i64.const ${lhs}) (i64.const ${rhs}))))`,
+                           'f',
+                           expect);
+}
+
+// Basic tests that addition and multiplication identities are collapsed, use
+// arg 1 here to force an explicit move to be emitted.
+
+for ( [op, args, expect] of
+      [['add',   '(local.get 1) (i64.const 0)', 'aa0103e0  mov     x0, x1'],
+       ['add',   '(i64.const 0) (local.get 1)', 'aa0103e0  mov     x0, x1'],
+       ['mul',   '(local.get 1) (i64.const 1)', 'aa0103e0  mov     x0, x1'],
+       ['mul',   '(i64.const 1) (local.get 1)', 'aa0103e0  mov     x0, x1']] ) {
+    codegenTestARM64_adhoc(`
+(module
+  (func (export "f") (param i64) (param i64) (result i64)
+    (i64.${op} ${args})))`,
+                           'f',
+                           expect);
+}
+
+// Test that multiplication by -1 yields negation.
+
+let neg32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const -1))))`;
+codegenTestARM64_adhoc(
+    neg32,
+    'f',
+    '4b0003e0  neg w0, w0');
+assertEq(wasmEvalText(neg32).exports.f(-37), 37)
+assertEq(wasmEvalText(neg32).exports.f(42), -42)
+
+let neg64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const -1))))`
+codegenTestARM64_adhoc(
+    neg64,
+    'f',
+    'cb0003e0  neg x0, x0');
+assertEq(wasmEvalText(neg64).exports.f(-37000000000n), 37000000000n)
+assertEq(wasmEvalText(neg64).exports.f(42000000000n), -42000000000n)
+
+// Test that multiplication by zero yields zero
+
+let zero32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 0))))`;
+codegenTestARM64_adhoc(
+    zero32,
+    'f',
+    '2a1f03e0  mov w0, wzr');
+assertEq(wasmEvalText(zero32).exports.f(-37), 0)
+assertEq(wasmEvalText(zero32).exports.f(42), 0)
+
+let zero64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 0))))`
+codegenTestARM64_adhoc(
+    zero64,
+    'f',
+    'aa1f03e0  mov x0, xzr');
+assertEq(wasmEvalText(zero64).exports.f(-37000000000n), 0n)
+assertEq(wasmEvalText(zero64).exports.f(42000000000n), 0n)
+
+// Test that multiplication by one yields no code (this optimization currently
+// exists both in constant folding and in lowering).
+
+let one32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 1))))`;
+codegenTestARM64_adhoc(
+    one32,
+    'f',
+    '');
+assertEq(wasmEvalText(one32).exports.f(-37), -37)
+assertEq(wasmEvalText(one32).exports.f(42), 42)
+
+let one64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 1))))`
+codegenTestARM64_adhoc(
+    one64,
+    'f',
+    '');
+assertEq(wasmEvalText(one64).exports.f(-37000000000n), -37000000000n)
+assertEq(wasmEvalText(one64).exports.f(42000000000n), 42000000000n)
+
+// Test that multiplication by two yields an add
+
+let double32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 2))))`;
+codegenTestARM64_adhoc(
+    double32,
+    'f',
+    '0b000000  add w0, w0, w0');
+assertEq(wasmEvalText(double32).exports.f(-37), -74)
+assertEq(wasmEvalText(double32).exports.f(42), 84)
+
+let double64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 2))))`
+codegenTestARM64_adhoc(
+    double64,
+    'f',
+    '8b000000  add x0, x0, x0');
+assertEq(wasmEvalText(double64).exports.f(-37000000000n), -74000000000n)
+assertEq(wasmEvalText(double64).exports.f(42000000000n), 84000000000n)
+
+// Test that multiplication by four yields a shift
+
+let quad32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 4))))`;
+codegenTestARM64_adhoc(
+    quad32,
+    'f',
+    '531e7400  lsl w0, w0, #2');
+assertEq(wasmEvalText(quad32).exports.f(-37), -148)
+assertEq(wasmEvalText(quad32).exports.f(42), 168)
+
+let quad64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 4))))`
+codegenTestARM64_adhoc(
+    quad64,
+    'f',
+    'd37ef400  lsl x0, x0, #2');
+assertEq(wasmEvalText(quad64).exports.f(-37000000000n), -148000000000n)
+assertEq(wasmEvalText(quad64).exports.f(42000000000n), 168000000000n)
+
+// Test that multiplication by five yields a multiply
+
+let quint32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 5))))`;
+codegenTestARM64_adhoc(
+    quint32,
+    'f',
+    `528000b0  mov     w16, #0x5
+     1b107c00  mul     w0, w0, w16`);
+assertEq(wasmEvalText(quint32).exports.f(-37), -37*5)
+assertEq(wasmEvalText(quint32).exports.f(42), 42*5)
+
+let quint64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 5))))`
+codegenTestARM64_adhoc(
+    quint64,
+    'f',
+    `d28000b0  mov     x16, #0x5
+     9b107c00  mul     x0, x0, x16`);
+assertEq(wasmEvalText(quint64).exports.f(-37000000000n), -37000000000n*5n)
+assertEq(wasmEvalText(quint64).exports.f(42000000000n), 42000000000n*5n)
+
+// Test that add/sub/and/or/xor don't need to reuse their input register.  The
+// proof here is that the destination register does not equal any of the input
+// registers.
+//
+// We have adequate functionality tests for these elsewhere, so test only
+// codegen here.
+
+for ( [op, imm, expectVar, expectImm] of
+      [['and', 64,
+        '8a020020  and     x0, x1, x2',
+        '927a0020  and     x0, x1, #0x40'],
+       ['or', 64,
+        'aa020020  orr     x0, x1, x2',
+        'b27a0020  orr     x0, x1, #0x40'],
+       ['xor', 64,
+        'ca020020  eor     x0, x1, x2',
+        'd27a0020  eor     x0, x1, #0x40'],
+       ['add', 64,
+        '8b020020  add     x0, x1, x2',
+        '91010020  add     x0, x1, #0x40 \\(64\\)'],
+       ['sub', 64,
+        'cb020020  sub     x0, x1, x2',
+        'd1010020  sub     x0, x1, #0x40 \\(64\\)']] ) {
+    codegenTestARM64_adhoc(`
+(module
+  (func (export "f") (param i64) (param i64) (param i64) (result i64)
+    (i64.${op} (local.get 1) (local.get 2))))`,
+                           'f',
+                           expectVar);
+    codegenTestARM64_adhoc(`
+(module
+  (func (export "f") (param i64) (param i64) (result i64)
+    (i64.${op} (local.get 1) (i64.const ${imm}))))`,
+                           'f',
+                           expectImm);
+}
+
+// Test that shifts and rotates with a constant don't need to reuse their input
+// register.  The proof here is that the destination register does not equal any
+// of the input registers.
+//
+// We have adequate functionality tests for these elsewhere, so test only
+// codegen here.
+
+for ( [op, expect] of
+      [['shl',   'd37ef420  lsl     x0, x1, #2'],
+       ['shr_s', '9342fc20  asr     x0, x1, #2'],
+       ['shr_u', 'd342fc20  lsr     x0, x1, #2'],
+       ['rotl',  '93c1f820  ror     x0, x1, #62'],
+       ['rotr',  '93c10820  ror     x0, x1, #2']] ) {
+    codegenTestARM64_adhoc(`
+(module
+  (func (export "f") (param i64) (param i64) (result i64)
+    (i64.${op} (local.get 1) (i64.const 2))))`,
+                           'f',
+                           expect);
+}
+
+// Test that 0-n yields negation.
+
+let subneg32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.sub (i32.const 0) (local.get 0))))`
+codegenTestARM64_adhoc(
+    subneg32,
+    'f',
+    '4b0003e0  neg w0, w0');
+assertEq(wasmEvalText(subneg32).exports.f(-37), 37)
+assertEq(wasmEvalText(subneg32).exports.f(42), -42)
+
+let subneg64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.sub (i64.const 0) (local.get 0))))`
+codegenTestARM64_adhoc(
+    subneg64,
+    'f',
+    'cb0003e0  neg x0, x0');
+assertEq(wasmEvalText(subneg64).exports.f(-37000000000n), 37000000000n)
+assertEq(wasmEvalText(subneg64).exports.f(42000000000n), -42000000000n)
+
+// Test that select does something reasonable and does not tie its output to one
+// of its inputs.
+
+codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param i64) (param i64) (param i64) (param i32) (result i64)
+         (select (local.get 1) (local.get 2) (local.get 3))))`,
+    'f',
+    `6a03007f  tst     w3, w3
+     9a821020  csel    x0, x1, x2, ne`)
+
+codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param f64) (param f64) (param f64) (param i32) (result f64)
+         (select (local.get 1) (local.get 2) (local.get 3))))`,
+    'f',
+    `6a00001f  tst     w0, w0
+     1e621c20  fcsel   d0, d1, d2, ne`)
+
+// Here we test that no boolean is generated and then re-tested, and that
+// operands are swapped so that we can use an immediate constant, and that the
+// input is not tied to the output.
+
+codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32)
+         (select (local.get $b) (local.get $d) (i32.lt_s (i32.const 0) (local.get $c)))))`,
+    'f',
+    `7100005f  cmp     w2, #0x0 \\(0\\)
+     1a83c020  csel    w0, w1, w3, gt`)
+
+codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)
+         (select (local.get $b) (local.get $d) (f64.lt (f64.const 0) (local.get $c)))))`,
+    'f',
+    `2f00e400  movi    d0, #0x0
+     1e622000  fcmp    d0, d2
+     1e633c20  fcsel   d0, d1, d3, lo`)
+
+// FP ABS should not tie its input to its output.
+
+codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param f32) (param f32) (result f32)
+         (f32.abs (local.get 1))))`,
+    'f',
+    '1e20c020  fabs    s0, s1');
+
+codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param f64) (param f64) (result f64)
+         (f64.abs (local.get 1))))`,
+    'f',
+    '1e60c020  fabs    d0, d1');
+
+// AND{32,64} followed by `== 0`: check the two operations are merged into a
+// single 'tst' insn, and no 'and' insn.  The merging isn't done for
+// {OR,XOR}{32,64}.  This is for both arguments being non-constant.
+
+for ( [ty, expect_tst] of
+      [['i32',   '6a01001f  tst w0, w1'],
+       ['i64',   'ea01001f  tst x0, x1']] ) {
+   codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param $p1 ${ty}) (param $p2 ${ty}) (result i32)
+         (local $x i32)
+         (set_local $x (i32.const 0x4D2))
+         (if (${ty}.eq (${ty}.and (local.get $p1) (local.get $p2))
+                       (${ty}.const 0))
+           (set_local $x (i32.const 0x11D7))
+         )
+         (get_local $x)
+       )
+    )`,
+    'f',
+    `${expect_tst}
+     54000061  b\\.ne  #\\+0xc \\(addr .*\\)
+     52823ae0  mov     w0, #0x11d7
+     14000002  b       #\\+0x8 \\(addr .*\\)
+     52809a40  mov     w0, #0x4d2`
+   );
+}
+
+// AND64 followed by `== 0`, with one of the args being a constant.
+
+for ( [imm, expect1, expect2] of
+      [ // as a valid logical-immediate => imm in insn
+        ['0x0F0F0F0F0F0F0F0F',
+         'f200cc1f  tst  x0, #0xf0f0f0f0f0f0f0f',
+         ''],
+        // anything else => imm synth'd into a reg
+        ['-0x4771',
+         '9288ee10  mov  x16, #0xffffffffffffb88f',
+         'ea10001f  tst  x0, x16']]
+      ) {
+   codegenTestARM64_adhoc(
+    `(module
+       (func (export "f") (param $p1 i64) (result i32)
+         (local $x i32)
+         (set_local $x (i32.const 0x4D2))
+         (if (i64.eq (i64.and (i64.const ${imm}) (local.get $p1))
+                     (i64.const 0))
+           (set_local $x (i32.const 0x11D7))
+         )
+         (get_local $x)
+       )
+    )`,
+    'f',
+    `${expect1}
+     ${expect2}
+     54000061  b\\.ne  #\\+0xc \\(addr .*\\)
+     52823ae0  mov     w0, #0x11d7
+     14000002  b       #\\+0x8 \\(addr .*\\)
+     52809a40  mov     w0, #0x4d2`
+   );
+}
+
+// For integer comparison followed by select, check that the comparison result
+// isn't materialised into a register, for specific types.
+
+for ( [cmpTy, cmpOp, selTy, cmpRegPfx, cselRegPfx, armCC] of
+      [ ['i32', 'le_s', 'i32',  'w', 'w', 'le'],
+        ['i32', 'lt_u', 'i64',  'w', 'x', 'lo'],
+        ['i64', 'le_s', 'i32',  'x', 'w', 'le'],
+        ['i64', 'lt_u', 'i64',  'x', 'x', 'lo'],
+      ] ) {
+   codegenTestARM64_adhoc(
+    `(module
+       (func (export "f")
+             (param $p1 ${cmpTy}) (param $p2 ${cmpTy})
+             (param $p3 ${selTy}) (param $p4 ${selTy})
+             (result ${selTy})
+         (select (local.get $p3)
+                 (local.get $p4)
+                 (${cmpTy}.${cmpOp} (local.get $p1) (local.get $p2)))
+       )
+    )`,
+    'f',
+    `.b01001f  cmp  ${cmpRegPfx}0, ${cmpRegPfx}1
+     .a83.040  csel ${cselRegPfx}0, ${cselRegPfx}2, ${cselRegPfx}3, ${armCC}`
+   );
+}
diff --git a/js/src/jit-test/tests/wasm/binop-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/binop-x64-ion-codegen.js
new file mode 100644
index 0000000000..93d0db1738
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/binop-x64-ion-codegen.js
@@ -0,0 +1,335 @@
+// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// There may be some redundant moves to set some operations up on x64 (that's
+// bug 1701164) so we avoid those with no_prefix/no_suffix flags when the issue
+// comes up.
+
+// Test that multiplication by -1 yields negation.
+
+let neg32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const -1))))`;
+codegenTestX64_adhoc(
+    neg32,
+    'f',
+    'f7 d8  neg %eax', {no_prefix:true});
+assertEq(wasmEvalText(neg32).exports.f(-37), 37)
+assertEq(wasmEvalText(neg32).exports.f(42), -42)
+
+let neg64 =
+    `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const -1))))`;
+codegenTestX64_adhoc(
+    neg64,
+    'f',
+    '48 f7 d8  neg %rax', {no_prefix:true});
+assertEq(wasmEvalText(neg64).exports.f(-37000000000n), 37000000000n)
+assertEq(wasmEvalText(neg64).exports.f(42000000000n), -42000000000n)
+
+// Test that multiplication by zero yields zero
+
+let zero32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 0))))`;
+codegenTestX64_adhoc(
+    zero32,
+    'f',
+    '33 c0 xor %eax, %eax', {no_prefix:true});
+assertEq(wasmEvalText(zero32).exports.f(-37), 0)
+assertEq(wasmEvalText(zero32).exports.f(42), 0)
+
+let zero64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 0))))`
+codegenTestX64_adhoc(
+    zero64,
+    'f',
+    '48 33 c0 xor %rax, %rax', {no_prefix:true});
+assertEq(wasmEvalText(zero64).exports.f(-37000000000n), 0n)
+assertEq(wasmEvalText(zero64).exports.f(42000000000n), 0n)
+
+// Test that multiplication by one yields no code
+
+let one32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 1))))`;
+codegenTestX64_adhoc(
+    one32,
+    'f',
+    '', {no_prefix:true});
+assertEq(wasmEvalText(one32).exports.f(-37), -37)
+assertEq(wasmEvalText(one32).exports.f(42), 42)
+
+let one64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 1))))`
+codegenTestX64_adhoc(
+    one64,
+    'f',
+    '', {no_prefix:true});
+assertEq(wasmEvalText(one64).exports.f(-37000000000n), -37000000000n)
+assertEq(wasmEvalText(one64).exports.f(42000000000n), 42000000000n)
+
+// Test that multiplication by two yields an add
+
+let double32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 2))))`;
+codegenTestX64_adhoc(
+    double32,
+    'f',
+    '03 c0 add %eax, %eax', {no_prefix:true});
+assertEq(wasmEvalText(double32).exports.f(-37), -74)
+assertEq(wasmEvalText(double32).exports.f(42), 84)
+
+let double64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 2))))`
+codegenTestX64_adhoc(
+    double64,
+    'f',
+    '48 03 c0 add %rax, %rax', {no_prefix:true});
+assertEq(wasmEvalText(double64).exports.f(-37000000000n), -74000000000n)
+assertEq(wasmEvalText(double64).exports.f(42000000000n), 84000000000n)
+
+// Test that multiplication by four yields a shift
+
+let quad32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 4))))`;
+codegenTestX64_adhoc(
+    quad32,
+    'f',
+    'c1 e0 02 shl \\$0x02, %eax', {no_prefix:true});
+assertEq(wasmEvalText(quad32).exports.f(-37), -148)
+assertEq(wasmEvalText(quad32).exports.f(42), 168)
+
+let quad64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 4))))`
+codegenTestX64_adhoc(
+    quad64,
+    'f',
+    '48 c1 e0 02 shl \\$0x02, %rax', {no_prefix:true});
+assertEq(wasmEvalText(quad64).exports.f(-37000000000n), -148000000000n)
+assertEq(wasmEvalText(quad64).exports.f(42000000000n), 168000000000n)
+
+// Test that multiplication by five yields a multiply
+
+let quint32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.mul (local.get 0) (i32.const 5))))`;
+codegenTestX64_adhoc(
+    quint32,
+    'f',
+    '6b c0 05 imul \\$0x05, %eax, %eax', {no_prefix:true});
+assertEq(wasmEvalText(quint32).exports.f(-37), -37*5)
+assertEq(wasmEvalText(quint32).exports.f(42), 42*5)
+
+let quint64 = `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.mul (local.get 0) (i64.const 5))))`
+codegenTestX64_adhoc(
+    quint64,
+    'f',
+    `48 6b c0 05               imul \\$0x05, %rax, %rax`, {no_prefix:true})
+assertEq(wasmEvalText(quint64).exports.f(-37000000000n), -37000000000n*5n)
+assertEq(wasmEvalText(quint64).exports.f(42000000000n), 42000000000n*5n)
+
+// Test that 0-n yields negation.
+
+let subneg32 =
+    `(module
+       (func (export "f") (param i32) (result i32)
+         (i32.sub (i32.const 0) (local.get 0))))`
+codegenTestX64_adhoc(
+    subneg32,
+    'f',
+    'f7 d8  neg %eax', {no_prefix:true});
+assertEq(wasmEvalText(subneg32).exports.f(-37), 37)
+assertEq(wasmEvalText(subneg32).exports.f(42), -42)
+
+let subneg64 =
+    `(module
+       (func (export "f") (param i64) (result i64)
+         (i64.sub (i64.const 0) (local.get 0))))`
+codegenTestX64_adhoc(
+    subneg64,
+    'f',
+    '48 f7 d8  neg %rax', {no_prefix:true});
+assertEq(wasmEvalText(subneg64).exports.f(-37000000000n), 37000000000n)
+assertEq(wasmEvalText(subneg64).exports.f(42000000000n), -42000000000n)
+
+// AND{32,64} followed by `== 0`: check the two operations are merged into a
+// single 'test' insn, and no 'and' insn.  The merging isn't done for
+// {OR,XOR}{32,64}.  This is for both arguments being non-constant.
+
+for ( [ty, expect_test] of
+      [['i32',   '85 ..     test %e.., %e..'],
+       ['i64',   '48 85 ..  test %r.., %r..']] ) {
+   codegenTestX64_adhoc(
+    `(module
+       (func (export "f") (param $p1 ${ty}) (param $p2 ${ty}) (result i32)
+         (local $x i32)
+         (set_local $x (i32.const 0x4D2))
+         (if (${ty}.eq (${ty}.and (local.get $p1) (local.get $p2))
+                       (${ty}.const 0))
+           (set_local $x (i32.const 0x11D7))
+         )
+         (get_local $x)
+       )
+    )`,
+    'f',
+    `${expect_test}
+     0f 85 .. 00 00 00   jnz 0x00000000000000..
+     b8 d7 11 00 00      mov \\$0x11D7, %eax
+     e9 .. 00 00 00      jmp 0x00000000000000..
+     b8 d2 04 00 00      mov \\$0x4D2, %eax`
+   );
+}
+
+// AND64 followed by `== 0`, with one of the args being a constant.  Depending
+// on the constant we can get one of three forms.
+
+for ( [imm, expect1, expect2] of
+      [ // in signed-32 range => imm in insn
+        ['0x17654321',
+         'f7 c. 21 43 65 17   test \\$0x17654321, %e..', // edi or ecx
+         ''],
+        // in unsigned-32 range => imm in reg via movl
+        ['0x87654321',
+         '41 bb 21 43 65 87   mov \\$-0x789ABCDF, %r11d',
+         '4c 85 d.            test %r11, %r..'], // rdi or rcx
+        // not in either range => imm in reg via mov(absq)
+        ['0x187654321',
+         '49 bb 21 43 65 87 01 00 00 00   mov \\$0x187654321, %r11',
+         '4c 85 d.   test %r11, %r..']] // rdi or rcx
+      ) {
+   codegenTestX64_adhoc(
+    `(module
+       (func (export "f") (param $p1 i64) (result i32)
+         (local $x i32)
+         (set_local $x (i32.const 0x4D2))
+         (if (i64.eq (i64.and (i64.const ${imm}) (local.get $p1))
+                     (i64.const 0))
+           (set_local $x (i32.const 0x11D7))
+         )
+         (get_local $x)
+       )
+    )`,
+    'f',
+    `${expect1}
+     ${expect2}
+     0f 85 .. 00 00 00   jnz 0x00000000000000..
+     b8 d7 11 00 00      mov \\$0x11D7, %eax
+     e9 .. 00 00 00      jmp 0x00000000000000..
+     b8 d2 04 00 00      mov \\$0x4D2, %eax`
+   );
+}
+
+// For integer comparison followed by select, check that the comparison result
+// isn't materialised into a register, for specific types.
+
+function cmpSel32vs64(cmpTy, cmpOp, selTy) {
+    return `(module
+              (func (export "f")
+                    (param $p1 ${cmpTy}) (param $p2 ${cmpTy})
+                    (param $p3 ${selTy}) (param $p4 ${selTy})
+                    (result ${selTy})
+                (select (local.get $p3)
+                        (local.get $p4)
+                        (${cmpTy}.${cmpOp} (local.get $p1) (local.get $p2)))
+              )
+            )`;
+}
+if (getBuildConfiguration().windows) {
+    for ( [cmpTy, cmpOp, selTy, insn1, insn2, insn3] of
+          [ ['i32', 'le_s', 'i32',  '8b c3        mov %ebx, %eax',
+                                    '3b ca        cmp %edx, %ecx',
+                                    '41 0f 4f c1  cmovnle %r9d, %eax'],
+            ['i32', 'lt_u', 'i64',  '48 89 d8     mov %rbx, %rax',
+                                    '3b ca        cmp %edx, %ecx',
+                                    '49 0f 43 c1  cmovnb %r9, %rax'],
+            ['i64', 'le_s', 'i32',  '8b c3        mov %ebx, %eax',
+                                    '48 3b ca     cmp %rdx, %rcx',
+                                    '41 0f 4f c1  cmovnle %r9d, %eax'],
+            ['i64', 'lt_u', 'i64',  '48 89 d8     mov %rbx, %rax',
+                                    '48 3b ca     cmp %rdx, %rcx',
+                                    '49 0f 43 c1  cmovnb %r9, %rax']
+          ] ) {
+        codegenTestX64_adhoc(cmpSel32vs64(cmpTy, cmpOp, selTy), 'f',
+          `4. (89 c3|8b d8)   mov %r8.*, %.bx
+           ${insn1}
+           ${insn2}
+           ${insn3}`
+        );
+    }
+} else {
+    for ( [cmpTy, cmpOp, selTy, insn1, insn2, insn3] of
+          [ ['i32', 'le_s', 'i32',  '8b c2        mov %edx, %eax',
+                                    '3b fe        cmp %esi, %edi',
+                                    '0f 4f c1     cmovnle %ecx, %eax'],
+            ['i32', 'lt_u', 'i64',  '48 89 d0     mov %rdx, %rax',
+                                    '3b fe        cmp %esi, %edi',
+                                    '48 0f 43 c1  cmovnb %rcx, %rax'],
+            ['i64', 'le_s', 'i32',  '8b c2        mov %edx, %eax',
+                                    '48 3b fe     cmp %rsi, %rdi',
+                                    '0f 4f c1     cmovnle %ecx, %eax'],
+            ['i64', 'lt_u', 'i64',  '48 89 d0     mov %rdx, %rax',
+                                    '48 3b fe     cmp %rsi, %rdi',
+                                    '48 0f 43 c1  cmovnb %rcx, %rax']
+          ] ) {
+        codegenTestX64_adhoc(cmpSel32vs64(cmpTy, cmpOp, selTy), 'f',
+          `${insn1}
+           ${insn2}
+           ${insn3}`
+        );
+    }
+}
+
+// For integer comparison followed by select, check correct use of operands in
+// registers vs memory.  At least for the 64-bit-cmp/64-bit-sel case.
+
+for ( [pAnyCmp, pAnySel, cmpBytes, cmpArgL, cmovBytes, cmovArgL ] of
+      [ // r, r
+        ['$pReg1', '$pReg2',
+         '4. .. ..', '%r.+',  '4. .. .. ..', '%r.+'],
+        // r, m
+        ['$pReg1', '$pMem2',
+         '4. .. ..', '%r.+',  '4. .. .. .. ..', '0x..\\(%rbp\\)'],
+        // m, r
+        ['$pMem1', '$pReg2',
+         '4. .. .. ..', '0x..\\(%rbp\\)', '4. .. .. ..', '%r.+'],
+        // m, m
+        ['$pMem1', '$pMem2',
+         '4. .. .. ..', '0x..\\(%rbp\\)', '4. .. .. .. ..', '0x..\\(%rbp\\)']
+      ] ) {
+   codegenTestX64_adhoc(
+    `(module
+       (func (export "f")
+             (param $p1 i64)    (param $p2 i64)     ;; in regs for both ABIs
+             (param $pReg1 i64) (param $pReg2 i64)  ;; in regs for both ABIs
+             (param i64)        (param i64)         ;; ignored
+             (param $pMem1 i64) (param $pMem2 i64)  ;; in mem for both ABIs
+             (result i64)
+         (select (local.get $p1)
+                 (local.get ${pAnySel})
+                 (i64.eq (local.get $p2) (local.get ${pAnyCmp})))
+       )
+    )`,
+    'f',
+    // On Linux we have an extra move
+    (getBuildConfiguration().windows ? '' : '48 89 ..       mov %r.+, %r.+\n') +
+    // 'q*' because the disassembler shows 'q' only for the memory cases
+    `48 89 ..       mov %r.+, %r.+
+     ${cmpBytes}    cmpq*    ${cmpArgL}, %r.+
+     ${cmovBytes}   cmovnzq* ${cmovArgL}, %r.+`
+   );
+}
diff --git a/js/src/jit-test/tests/wasm/binop-x64-ion-folding.js b/js/src/jit-test/tests/wasm/binop-x64-ion-folding.js
new file mode 100644
index 0000000000..a812abcd34
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/binop-x64-ion-folding.js
@@ -0,0 +1,212 @@
+// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// This file checks folding rules for wasm {and,or,xor}{32,64} on x64 via Ion.
+// See also binop-x64-ion-codegen.js, which is similar.
+
+// These tests check that a folding has happened.  The function is also run
+// and the result value checked.  Note, many of the functions ignore one or
+// both of their parameters.
+//
+// In many cases the expected code contains an unnecessary move via a
+// temporary, generally e/rcx, for example:
+//
+//   mov %rdi, %rcx
+//   mov %rcx, %rax
+//
+// where rdi is the first arg reg (on Linux) and rax is the retval reg.  This
+// is documented in bug 1701164.  If/when that gets fixed, we will presumably
+// have to redo the expected-outputs here.
+//
+// The situation is complicated further because many of the expected outputs
+// here depend on one of the two argument registers, but they are different in
+// the ELF ABI (rdi, rsi) and the Win64 ABI (rcx, rdx).  For the latter case,
+// the abovementioned spurious move from the first arg reg into rcx
+// disappears.  Hence there is some fudging using wildcards in register names,
+// and `no_prefix`, to make the tests pass with both ABIs.
+
+function test(ty, wasm_insn, must_appear, param0, param1, expected_result,
+              options = {}) {
+    let t =
+        `(module
+           (func (export "f") (param ${ty}) (param ${ty}) (result ${ty})
+             ${wasm_insn}
+        ))`;
+    options.instanceBox = {value: null};
+    codegenTestX64_adhoc(t, "f", must_appear, options);
+    let ins = options.instanceBox.value;
+    assertEq(ins.exports.f(param0, param1), expected_result);
+}
+
+function test32(wasm_insn, must_appear, param0, param1, expected_result,
+                options) {
+    return test('i32', wasm_insn, must_appear, param0, param1, expected_result,
+                options);
+}
+
+function test64(wasm_insn, must_appear, param0, param1, expected_result,
+                options) {
+    return test('i64', wasm_insn, must_appear, param0, param1, expected_result,
+               options);
+}
+
+// {AND,OR,XOR}{32,64} folding: both args const
+
+test32('(i32.and (i32.const 0x12345678) (i32.const 0x0f0f0f0f))',
+       'b8 08 06 04 02   mov \\$0x2040608, %eax',
+       0,0, 0x2040608);
+test64('(i64.and (i64.const 0x1234567851505150) (i64.const 0x515051500f0f0f0f))',
+       '48 b8 00 01 00 01 50 50 10 10   mov \\$0x1010505001000100, %rax',
+       0n,0n, 0x1010505001000100n);
+
+test32('(i32.or (i32.const 0x12345678) (i32.const 0x0f0e0d0c))',
+       'b8 7c 5f 3e 1f   mov \\$0x1F3E5F7C, %eax',
+       0,0, 0x1f3e5f7c);
+test64('(i64.or (i64.const 0x1234567851505150) (i64.const 0x515051500f0f1337))',
+       '48 b8 77 53 5f 5f 78 57 74 53   mov \\$0x537457785F5F5377, %rax',
+       0n,0n, 0x537457785f5f5377n);
+
+test32('(i32.xor (i32.const 0x12345678) (i32.const 0x0f0e0d0c))',
+       'b8 74 5b 3a 1d   mov \\$0x1D3A5B74, %eax',
+       0,0, 0x1d3a5b74);
+test64('(i64.xor (i64.const 0x1234567851505150) (i64.const 0x515051500f0f1337))',
+       '48 b8 67 42 5f 5e 28 07 64 43   mov \\$0x436407285E5F4267, %rax',
+       0n,0n, 0x436407285e5f4267n);
+
+// {AND,OR,XOR}{32,64} identities: first arg is all zeroes
+
+test32('(i32.and (i32.const 0) (get_local 1))',
+       '33 c0   xor %eax, %eax',
+       1234,5678, 0);
+test64('(i64.and (i64.const 0) (get_local 1))',
+       '33 c0   xor %eax, %eax',
+       1234n,5678n, 0n);
+
+test32('(i32.or (i32.const 0) (get_local 1))',
+       `8b ..   mov %e.., %ecx
+        8b c1   mov %ecx, %eax`,
+       1234,5678, 5678);
+test64('(i64.or (i64.const 0) (get_local 1))',
+       `48 89 ..   mov %r.., %rcx
+        48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 5678n);
+
+test32('(i32.xor (i32.const 0) (get_local 1))',
+       `8b ..   mov %e.., %ecx
+        8b c1   mov %ecx, %eax`,
+       1234,5678, 5678);
+test64('(i64.xor (i64.const 0) (get_local 1))',
+       `48 89 ..   mov %r.., %rcx
+        48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 5678n);
+
+// {AND,OR,XOR}{32,64} identities: second arg is all zeroes
+
+test32('(i32.and (get_local 0) (i32.const 0))',
+       '33 c0   xor %eax, %eax',
+       1234,5678, 0);
+test64('(i64.and (get_local 0) (i64.const 0))',
+       '33 c0   xor %eax, %eax',
+       1234n,5678n, 0n);
+
+test32('(i32.or (get_local 0) (i32.const 0))',
+     // 8b cf   mov %edi, %ecx  -- expected on Linux but not on Windows
+       `8b c1   mov %ecx, %eax`,
+       1234,5678, 1234, {no_prefix: true}); // required on Linux
+test64('(i64.or (get_local 0) (i64.const 0))',
+     // 48 89 f9   mov %rdi, %rcx  -- ditto
+       `48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 1234n, {no_prefix: true});
+
+test32('(i32.xor (get_local 0) (i32.const 0))',
+     // 8b cf   mov %edi, %ecx  -- ditto
+       `8b c1   mov %ecx, %eax`,
+       1234,5678, 1234, {no_prefix: true});
+test64('(i64.xor (get_local 0) (i64.const 0))',
+     // 48 89 f9   mov %rdi, %rcx  -- ditto
+       `48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 1234n, {no_prefix: true});
+
+// {AND,OR,XOR}{32,64} identities: first arg is all ones
+
+test32('(i32.and (i32.const 0xffffffff) (get_local 1))',
+       `8b ..   mov %e.., %ecx
+        8b c1   mov %ecx, %eax`,
+       1234,5678, 5678);
+test64('(i64.and (i64.const 0xffffffffffffffff) (get_local 1))',
+       `48 89 ..   mov %r.., %rcx
+        48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 5678n);
+
+test32('(i32.or (i32.const 0xffffffff) (get_local 1))',
+       'b8 ff ff ff ff   mov \\$-0x01, %eax',
+       1234,5678, -1/*0xffffffff*/);
+test64('(i64.or (i64.const 0xffffffffffffffff) (get_local 1))',
+       '48 c7 c0 ff ff ff ff   mov \\$-0x01, %rax',
+       1234n,5678n, -1n/*0xffffffffffffffff*/);
+
+test32('(i32.xor (i32.const 0xffffffff) (get_local 1))',
+       `8b ..   mov %e.., %ecx
+        8b c1   mov %ecx, %eax
+        f7 d0   not %eax`,
+       1234,5678, -5679);
+test64('(i64.xor (i64.const 0xffffffffffffffff) (get_local 1))',
+       `48 89 ..   mov %r.., %rcx
+        48 89 c8   mov %rcx, %rax
+        48 f7 d0   not %rax`,
+       1234n,5678n, -5679n);
+
+// {AND,OR,XOR}{32,64} identities: second arg is all ones
+
+test32('(i32.and (get_local 0) (i32.const 0xffffffff))',
+     // 8b cf   mov %edi, %ecx  -- expected on Linux but not on Windows
+       `8b c1   mov %ecx, %eax`,
+       1234,5678, 1234, {no_prefix: true}); // required on Linux
+test64('(i64.and (get_local 0) (i64.const 0xffffffffffffffff))',
+     // 48 89 f9   mov %rdi, %rcx  -- ditto
+       `48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 1234n, {no_prefix: true});
+
+test32('(i32.or (get_local 0) (i32.const 0xffffffff))',
+       'b8 ff ff ff ff   mov \\$-0x01, %eax',
+       1234,5678, -1/*0xffffffff*/);
+test64('(i64.or (get_local 0) (i64.const 0xffffffffffffffff))',
+       '48 c7 c0 ff ff ff ff   mov \\$-0x01, %rax',
+       1234n,5678n, -1n/*0xffffffffffffffff*/);
+
+test32('(i32.xor (get_local 0) (i32.const 0xffffffff))',
+     // 8b cf   mov %edi, %ecx  -- ditto
+       `8b c1   mov %ecx, %eax
+        f7 d0   not %eax`,
+       1234,5678, -1235, {no_prefix: true});
+test64('(i64.xor (get_local 0) (i64.const 0xffffffffffffffff))',
+     // 48 89 f9   mov %rdi, %rcx  -- ditto
+       `48 89 c8   mov %rcx, %rax
+        48 f7 d0   not %rax`,
+       1234n,5678n, -1235n, {no_prefix: true});
+
+// {AND,OR,XOR}{32,64} identities: both args the same
+
+test32('(i32.and (get_local 0) (get_local 0))',
+     // 8b cf   mov %edi, %ecx  -- ditto
+       `8b c1   mov %ecx, %eax`,
+       1234,5678, 1234, {no_prefix: true});
+test64('(i64.and (get_local 0) (get_local 0))',
+     // 48 89 f9   mov %rdi, %rcx  -- ditto
+       `48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 1234n, {no_prefix: true});
+
+test32('(i32.or (get_local 0) (get_local 0))',
+     // 8b cf   mov %edi, %ecx  -- ditto
+       `8b c1   mov %ecx, %eax`,
+       1234,5678, 1234, {no_prefix: true});
+test64('(i64.or (get_local 0) (get_local 0))',
+     // 48 89 f9   mov %rdi, %rcx  -- ditto
+       `48 89 c8   mov %rcx, %rax`,
+       1234n,5678n, 1234n, {no_prefix: true});
+
+test32('(i32.xor (get_local 0) (get_local 0))',
+       '33 c0   xor %eax, %eax',
+       1234,5678, 0);
+test64('(i64.xor (get_local 0) (get_local 0))',
+       '33 c0   xor %eax, %eax',
+       1234n,5678n, 0n);
diff --git a/js/src/jit-test/tests/wasm/bug1693500.js b/js/src/jit-test/tests/wasm/bug1693500.js
new file mode 100644
index 0000000000..932dba1a57
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bug1693500.js
@@ -0,0 +1,73 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || wasmCompileMode() != "ion" || (!getBuildConfiguration().x86 && !getBuildConfiguration().x64) || getBuildConfiguration().simulator
+
+const avx = isAvxPresent();
+for (let [n1, n2, numInstr] of [
+    [0x123456789abn, 0xffeeddccbbaa9988n, avx ? 6 : 7],
+    [42n, 0xFFFFFFFFn, avx ? 3 : 4],
+    [0n, 0n, 1],
+    [1n, 1n, 1],
+    ...iota(63).map(i => [2n << BigInt(i), 2n << BigInt(i), 1]),
+    ...iota(63).reduce((acc, i) => {
+        const base = 2n << BigInt(i);
+        return acc.concat(iota(i + 1).map(j => [
+            base | (1n << BigInt(j)), base | (1n << BigInt(j)),
+            (avx ? 2 : 3) + (j == 0 ? 0 : 1)]));
+    }, []),
+    ...iota(63).map(i => [~(1n << BigInt(i)), ~(1n << BigInt(i)), avx ? 5 : 6]),
+    [0x7fffffffffffffffn, 0x7fffffffffffffffn, avx ? 5 : 6],
+    [-1n, -1n, 3],
+]) {
+    var wasm = wasmTextToBinary(`(module
+        (memory (export "memory") 1 1)
+        (func $t (export "t") (param v128) (result v128)
+            local.get 0
+            v128.const i64x2 ${n1} ${n2}
+            i64x2.mul
+        )
+        (func $t0 (param v128 v128) (result v128)
+            local.get 0
+            local.get 1
+            i64x2.mul
+        )
+        (func (export "run") (result i32)
+            i32.const 16
+            i32.const 0
+            v128.load
+            call $t
+            v128.store
+
+            v128.const i64x2 ${n1} ${n2}
+            i32.const 0
+            v128.load
+            call $t0
+
+            i32.const 16
+            v128.load
+            i64x2.eq
+            i64x2.all_true
+        )
+    )`)
+
+    var ins = new WebAssembly.Instance(new WebAssembly.Module(wasm));
+    var mem64 = new BigInt64Array(ins.exports.memory.buffer, 0, 4);
+
+    for (let [t1, t2] of [
+        [1n, 1n], [-1n, -2n], [0n, 0n], [0x123456789abn, 0xffeeddccbbaa9988n],
+        [0x100001111n, -0xFF0011n], [5555n, 0n],
+    ]) {
+        mem64[0] = t1; mem64[1] = t2;
+        assertEq(ins.exports.run(), 1);
+    }
+
+    if (hasDisassembler() && getBuildConfiguration().x64) {
+        const dis = wasmDis(ins.exports.t, {asString: true,});
+        const lines = getFuncBody(dis).trim().split('\n');
+        assertEq(lines.length, numInstr);
+    }
+}
+
+// Utils.
+function getFuncBody(dis) {
+    const parts = dis.split(/mov %rsp, %rbp\n|^[0-9A-Fa-f ]+pop %rbp/gm);
+    return parts.at(-2).replace(/[0-9A-F]{8} (?: [0-9a-f]{2})+[\s\n]+/g, "");
+}
diff --git a/js/src/jit-test/tests/wasm/bug1776358.js b/js/src/jit-test/tests/wasm/bug1776358.js
new file mode 100644
index 0000000000..b2cf178bf2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/bug1776358.js
@@ -0,0 +1,28 @@
+let func = wasmEvalText(`(module
+    (func
+        (param f64) (param f64) (param f64) (param f64) (param f64)
+        (param f64) (param f64) (param f64) (param f64)
+    )
+    (func
+        (param i32)
+        (result i32)
+        ;; Call in a dead branch.
+        (if (i32.const 0) (then
+          (call 0
+            (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0)
+            (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0)
+          )
+        ))
+        ;; Division to trigger a trap.
+        (i32.div_s (get_local 0) (get_local 0))
+    )
+    (export "" (func 1))
+)`).exports[""];
+assertEq(func(7), 1);
+let ex;
+try {
+    func(0);
+} catch (e) {
+    ex = e;
+}
+assertEq(ex instanceof WebAssembly.RuntimeError, true);
diff --git a/js/src/jit-test/tests/wasm/builtin.js b/js/src/jit-test/tests/wasm/builtin.js
new file mode 100644
index 0000000000..65d673d9a7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/builtin.js
@@ -0,0 +1,132 @@
+let values = [-Infinity, Infinity, NaN, 0, -0, -0.1, 0.1, 0.5, -1.6, 1.6, 13.37];
+
+function unary(name) {
+    print(name);
+
+    let imports = {
+        math: {
+            func: Math[name],
+        }
+    };
+
+    let f32 = x => Math.fround(Math[name](Math.fround(x)));
+    let f64 = Math[name];
+
+    let i = wasmEvalText(`(module
+        (import "math" "func" (func $f32 (param f32) (result f32)))
+        (import "math" "func" (func $f64 (param f64) (result f64)))
+
+        (table $t 10 funcref)
+        (type $f_f (func (param f32) (result f32)))
+        (type $d_d (func (param f64) (result f64)))
+        (elem (i32.const 0) $f32 $f64)
+
+        (func (export "f32") (param f32) (result f32)
+            local.get 0
+            call $f32
+        )
+        (func (export "f32_t") (param f32) (result f32)
+            local.get 0
+            i32.const 0
+            call_indirect (type $f_f)
+        )
+        (func (export "f64") (param f64) (result f64)
+            local.get 0
+            call $f64
+        )
+        (func (export "f64_t") (param f64) (result f64)
+            local.get 0
+            i32.const 1
+            call_indirect (type $d_d)
+        )
+    )`, imports).exports;
+
+    for (let v of values) {
+        assertEq(i.f32(v), f32(v));
+        assertEq(i.f32_t(v), f32(v));
+        assertEq(i.f64(v), f64(v));
+        assertEq(i.f64_t(v), f64(v));
+    }
+}
+
+function binary(name) {
+    print(name);
+
+    let imports = {
+        math: {
+            func: Math[name]
+        }
+    };
+
+    let f32 = (x, y) => Math.fround(Math[name](Math.fround(x), Math.fround(y)));
+    let f64 = Math[name];
+
+    let i = wasmEvalText(`(module
+        (import "math" "func" (func $f32 (param f32) (param f32) (result f32)))
+        (import "math" "func" (func $f64 (param f64) (param f64) (result f64)))
+
+        (table $t 10 funcref)
+        (type $ff_f (func (param f32) (param f32) (result f32)))
+        (type $dd_d (func (param f64) (param f64) (result f64)))
+        (elem (i32.const 0) $f32 $f64)
+
+        (func (export "f32") (param f32) (param f32) (result f32)
+            local.get 0
+            local.get 1
+            call $f32
+        )
+        (func (export "f32_t") (param f32) (param f32) (result f32)
+            local.get 0
+            local.get 1
+            i32.const 0
+            call_indirect (type $ff_f)
+        )
+        (func (export "f64") (param f64) (param f64) (result f64)
+            local.get 0
+            local.get 1
+            call $f64
+        )
+        (func (export "f64_t") (param f64) (param f64) (result f64)
+            local.get 0
+            local.get 1
+            i32.const 1
+            call_indirect (type $dd_d)
+        )
+    )`, imports).exports;
+
+    for (let v of values) {
+        for (let w of values) {
+            assertEq(i.f32(v, w), f32(v, w));
+            assertEq(i.f64(v, w), f64(v, w));
+        }
+    }
+}
+
+unary('sin');
+unary('sin');
+unary('tan');
+unary('cos');
+unary('exp');
+unary('log');
+unary('asin');
+unary('atan');
+unary('acos');
+unary('log10');
+unary('log2');
+unary('log1p');
+unary('expm1');
+unary('sinh');
+unary('tanh');
+unary('cosh');
+unary('asinh');
+unary('atanh');
+unary('acosh');
+unary('sign');
+unary('trunc');
+unary('cbrt');
+
+binary('atan2');
+binary('hypot');
+binary('pow');
+
+print('done');
diff --git a/js/src/jit-test/tests/wasm/caching.js b/js/src/jit-test/tests/wasm/caching.js
new file mode 100644
index 0000000000..d826d5c01c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/caching.js
@@ -0,0 +1,63 @@
+// |jit-test| skip-if: !wasmCachingEnabled()
+
+load(libdir + "wasm-caching.js");
+load(libdir + "wasm-binary.js");
+
+testCached(`(module
+    (func $test (param i64) (result f64)
+        local.get 0
+        f64.convert_u/i64
+    )
+    (func (export "run") (result i32)
+        i64.const 1
+        call $test
+        f64.const 1
+        f64.eq
+    )
+)`,
+    undefined,
+    i => { assertEq(i.exports.run(), 1); }
+);
+
+testCached(
+    `(module
+       (type $long-serialized-type (func (param
+          i64 i32 f64 f32 i64 i32 f64 f32 i64 i32 f64 f32 i64 i32 f64 f32))) 
+       (func (export "run") (result i32)
+         (i32.const 42)))`,
+    undefined,
+    i => { assertEq(i.exports.run(), 42); }
+);
+
+testCached(
+    `(module
+       (type $T (func (result i32)))
+       (func $t1 (import "" "t1") (type $T))
+       (func $t2 (import "" "t2") (type $T))
+       (func $t3 (type $T) (i32.const 30))
+       (func $t4 (type $T) (i32.const 40))
+       (table funcref (elem $t1 $t2 $t3 $t4))
+       (func (export "run") (param i32) (result i32)
+         (call_indirect (type $T) (local.get 0))))`,
+    {'':{ t1() { return 10 }, t2() { return 20 } }},
+    i => {
+        assertEq(i.exports.run(0), 10);
+        assertEq(i.exports.run(1), 20);
+        assertEq(i.exports.run(2), 30);
+        assertEq(i.exports.run(3), 40);
+    }
+);
+
+testCached(
+  moduleWithSections([
+    sigSection([{args:[], ret:VoidCode}]),
+    declSection([0]),
+    exportSection([{funcIndex:0, name:"run"}]),
+    bodySection([funcBody({locals:[], body:[UnreachableCode]})]),
+    nameSection([funcNameSubsection([{name:"wee"}])])
+  ]),
+  undefined,
+  i => assertErrorMessage(() => i.exports.run(), RuntimeError, /unreachable/)
+);
+
+// Note: a fuller behavioral test of caching is in bench/wasm_box2d.js.
diff --git a/js/src/jit-test/tests/wasm/comments.js b/js/src/jit-test/tests/wasm/comments.js
new file mode 100644
index 0000000000..4fc29ec19b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/comments.js
@@ -0,0 +1,31 @@
+// sanity check
+assertErrorMessage(() => wasmEvalText(''), SyntaxError, /wasm text error/);
+
+// single line comment
+var o = wasmEvalText('(module (func)) ;; end');
+var o = wasmEvalText('(module (func)) ;; end\n');
+var o = wasmEvalText('(module (func))\n;; end');
+var o = wasmEvalText('(module (func))\n;; end');
+var o = wasmEvalText(';;start\n(module (func))');
+var o = wasmEvalText('(module (func ;; middle\n))');
+var o = wasmEvalText('(module (func) ;; middle\n (export "a" (func 0)))').exports;
+assertEq(Object.getOwnPropertyNames(o)[0], "a");
+
+// multi-line comments
+var o = wasmEvalText('(module (func))(; end ;)');
+var o = wasmEvalText('(module (func)) (; end\nmulti;)\n');
+var o = wasmEvalText('(module (func))\n(;;)');
+var o = wasmEvalText('(;start;)(module (func))');
+var o = wasmEvalText('(;start;)\n(module (func))');
+var o = wasmEvalText('(module (func (; middle\n multi\n;)))');
+var o = wasmEvalText('(module (func)(;middle;)(export "a" (func 0)))').exports;
+assertEq(Object.getOwnPropertyNames(o)[0], "a");
+
+// nested comments
+var o = wasmEvalText('(module (;nested(;comment;);)(func (;;;;)))');
+var o = wasmEvalText(';;;;;;;;;;\n(module ;;(;n \n(func (;\n;;;)))');
+
+assertErrorMessage(() => wasmEvalText(';; only comment'), SyntaxError, /wasm text error/);
+assertErrorMessage(() => wasmEvalText(';; only comment\n'), SyntaxError, /wasm text error/);
+assertErrorMessage(() => wasmEvalText('(; only comment ;)'), SyntaxError, /wasm text error/);
+assertErrorMessage(() => wasmEvalText(';; only comment\n'), SyntaxError, /wasm text error/);
diff --git a/js/src/jit-test/tests/wasm/compare-select-i32-i64.js b/js/src/jit-test/tests/wasm/compare-select-i32-i64.js
new file mode 100644
index 0000000000..34657053ac
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/compare-select-i32-i64.js
@@ -0,0 +1,269 @@
+
+// Comprehensively test wasm compare-then-select, for all combinations of
+//
+//   compare     in  i32 i64
+//   select      in  i32 i64
+//   compare-op  in  eq ne lt_s lt_u gt_s gt_u le_s le_u ge_s ge_u
+//
+// and using comparison values from all 4 quadrant points of the range,
+// including at least one either side, so as to catch off-by-one comparison
+// errors.  In total 9000 tests.
+
+const cmpVals32
+      = [ 0x00000000, 0x00000001, 0x00000002,
+          0x3fffffff, 0x40000000, 0x40000001,
+          0x7fffffff, 0x80000000, 0x80000001,
+          0xbfffffff, 0xc0000000, 0xc0000001,
+          0xfffffffd, 0xfffffffe, 0xffffffff ];
+
+const cmpVals64
+      = [ 0x0000000000000000n, 0x0000000000000001n, 0x0000000000000002n,
+          0x3fffffffffffffffn, 0x4000000000000000n, 0x4000000000000001n,
+          0x7fffffffffffffffn, 0x8000000000000000n, 0x8000000000000001n,
+          0xbfffffffffffffffn, 0xc000000000000000n, 0xc000000000000001n,
+          0xfffffffffffffffdn, 0xfffffffffffffffen, 0xffffffffffffffffn ];
+
+const selVal32L = 0x55551234;
+const selVal32R = 0x55554321;
+
+const selVal64L = 0x5555555555554771n;
+const selVal64R = 0x5555555555551337n;
+
+function getCmpVals(cmpTy) {
+    if (cmpTy === 'i32') {
+        return cmpVals32;
+    } else {
+        assertEq(cmpTy, 'i64');
+        return cmpVals64;
+    }
+}
+
+function classifyResult(selTy, result) {
+    if (selTy === 'i32') {
+        if (result === selVal32L) {
+            return '0';
+        }
+        if (result === selVal32R) {
+            return '1';
+        }
+    } else {
+        assertEq(selTy, 'i64');
+        if (result === selVal64L) {
+            return '2';
+        }
+        if (result === selVal64R) {
+            return '3';
+        }
+    }
+    // Anything that is not '0', '1', '2' or '3' will cause the final
+    // summary-string comparison below to fail.
+    return 'BAD';
+}
+
+let actualSummaryString = '';
+
+for ( cmpTy of [ 'i32', 'i64' ] ) {
+    for ( selTy of [ 'i32', 'i64' ] ) {
+        for ( cmpOp of [ 'eq', 'ne',
+                         'lt_s', 'lt_u', 'gt_s', 'gt_u',
+                         'le_s', 'le_u', 'ge_s', 'ge_u' ] ) {
+            let t =
+             `(module
+                (func (export "f")
+                      (param $p1 ${cmpTy}) (param $p2 ${cmpTy})
+                      (param $p3 ${selTy}) (param $p4 ${selTy})
+                      (result ${selTy})
+                  (select (local.get $p3)
+                          (local.get $p4)
+                          (${cmpTy}.${cmpOp} (local.get $p1) (local.get $p2)))
+                )
+              )`;
+            let i = new WebAssembly.Instance(
+                    new WebAssembly.Module(wasmTextToBinary(t)));
+            let cmpVals = getCmpVals(cmpTy);
+            let selValL, selValR;
+            if (selTy === 'i32') {
+                selValL = selVal32L;
+                selValR = selVal32R;
+            } else {
+                assertEq(selTy, 'i64');
+                selValL = selVal64L;
+                selValR = selVal64R;
+            }
+            for ( cmpValL of cmpVals ) {
+                for ( cmpValR of cmpVals ) {
+                    let res = i.exports.f(cmpValL, cmpValR, selValL, selValR);
+                    // We expect res to be one of selVal<selTy>{L,R} values.
+                    // Check that and add its summary to the running string.
+                    let classified = classifyResult(selTy, res);
+                    actualSummaryString += classified;
+                }
+            }
+        }
+    }
+}
+
+// We expect to run exactly 9000 tests:
+// 2 cmp types x 2 sel types x 10 conditions  (= 40 wasm functions)
+//             x 15 cmp argLs x 15 cmp argRs   = 9000
+assertEq(actualSummaryString.length, 9000);
+
+// The expected summary string, one char for each test, encoded per
+// function classifyResult above.  150 lines of 60 chars each.
+
+let expectedSummaryString
+ =
+  '011111111111111101111111111111110111111111111111011111111111' +
+  '111101111111111111110111111111111111011111111111111101111111' +
+  '111111110111111111111111011111111111111101111111111111110111' +
+  '111111111111011111111111111101111111111111110100000000000000' +
+  '010000000000000001000000000000000100000000000000010000000000' +
+  '000001000000000000000100000000000000010000000000000001000000' +
+  '000000000100000000000000010000000000000001000000000000000100' +
+  '000000000000010000000000000001100000011111111110000011111111' +
+  '111000011111111111100011111111111110011111111111111011111111' +
+  '111111111111111000000010000000000000011000000000000011100000' +
+  '000000011110000000000011111000000000011111100000000011111110' +
+  '000000011111111100000000000000110000000000000111000000000000' +
+  '111100000000000111110000000000111111000000000111111100000000' +
+  '111111110000000111111111000000111111111100000111111111110000' +
+  '111111111111000111111111111100111111111111110111111111111111' +
+  '111111100000000011111100000000001111100000000000111100000000' +
+  '000011100000000000001100000000000000100000000111111111111111' +
+  '111111101111111111111100111111111111100011111111111100001111' +
+  '111111100000111111111100000011111111100000001111111111111111' +
+  '011111111111111001111111111111000111111111111000011111111111' +
+  '000001111111111000000111111111000000011111111000000001111111' +
+  '000000000111111000000000011111000000000001111000000000000111' +
+  '000000000000011000000000000001000000011111111100000011111111' +
+  '110000011111111111000011111111111100011111111111110011111111' +
+  '111111011111111000000000000000000000010000000000000011000000' +
+  '000000011100000000000011110000000000011111000000000011111100' +
+  '000000011111110000000000000000100000000000000110000000000000' +
+  '111000000000000111100000000000111110000000000111111000000000' +
+  '111111100000000111111110000000111111111000000111111111100000' +
+  '111111111110000111111111111000111111111111100111111111111110' +
+  '011111100000000001111100000000000111100000000000011100000000' +
+  '000001100000000000000100000000000000000000000111111101111111' +
+  '111111100111111111111100011111111111100001111111111100000111' +
+  '111111100000011111111100000001111111100000000011111111111111' +
+  '001111111111111000111111111111000011111111111000001111111111' +
+  '000000111111111000000011111111000000001111111000000000111111' +
+  '000000000011111000000000001111000000000000111000000000000011' +
+  '000000000000001000000000000000233333333333333323333333333333' +
+  '332333333333333333233333333333333323333333333333332333333333' +
+  '333333233333333333333323333333333333332333333333333333233333' +
+  '333333333323333333333333332333333333333333233333333333333323' +
+  '333333333333332322222222222222232222222222222223222222222222' +
+  '222322222222222222232222222222222223222222222222222322222222' +
+  '222222232222222222222223222222222222222322222222222222232222' +
+  '222222222223222222222222222322222222222222232222222222222223' +
+  '322222233333333332222233333333333222233333333333322233333333' +
+  '333332233333333333333233333333333333333333333222222232222222' +
+  '222222233222222222222233322222222222233332222222222233333222' +
+  '222222233333322222222233333332222222233333333322222222222222' +
+  '332222222222222333222222222222333322222222222333332222222222' +
+  '333333222222222333333322222222333333332222222333333333222222' +
+  '333333333322222333333333332222333333333333222333333333333322' +
+  '333333333333332333333333333333333333322222222233333322222222' +
+  '223333322222222222333322222222222233322222222222223322222222' +
+  '222222322222222333333333333333333333323333333333333322333333' +
+  '333333322233333333333322223333333333322222333333333322222233' +
+  '333333322222223333333333333333233333333333333223333333333333' +
+  '222333333333333222233333333333222223333333333222222333333333' +
+  '222222233333333222222223333333222222222333333222222222233333' +
+  '222222222223333222222222222333222222222222233222222222222223' +
+  '222222233333333322222233333333332222233333333333222233333333' +
+  '333322233333333333332233333333333333233333333222222222222222' +
+  '222222232222222222222233222222222222233322222222222233332222' +
+  '222222233333222222222233333322222222233333332222222222222222' +
+  '322222222222222332222222222222333222222222222333322222222222' +
+  '333332222222222333333222222222333333322222222333333332222222' +
+  '333333333222222333333333322222333333333332222333333333333222' +
+  '333333333333322333333333333332233333322222222223333322222222' +
+  '222333322222222222233322222222222223322222222222222322222222' +
+  '222222222222222333333323333333333333322333333333333322233333' +
+  '333333322223333333333322222333333333322222233333333322222223' +
+  '333333322222222233333333333333223333333333333222333333333333' +
+  '222233333333333222223333333333222222333333333222222233333333' +
+  '222222223333333222222222333333222222222233333222222222223333' +
+  '222222222222333222222222222233222222222222223222222222222222' +
+  '011111111111111101111111111111110111111111111111011111111111' +
+  '111101111111111111110111111111111111011111111111111101111111' +
+  '111111110111111111111111011111111111111101111111111111110111' +
+  '111111111111011111111111111101111111111111110100000000000000' +
+  '010000000000000001000000000000000100000000000000010000000000' +
+  '000001000000000000000100000000000000010000000000000001000000' +
+  '000000000100000000000000010000000000000001000000000000000100' +
+  '000000000000010000000000000001100000011111111110000011111111' +
+  '111000011111111111100011111111111110011111111111111011111111' +
+  '111111111111111000000010000000000000011000000000000011100000' +
+  '000000011110000000000011111000000000011111100000000011111110' +
+  '000000011111111100000000000000110000000000000111000000000000' +
+  '111100000000000111110000000000111111000000000111111100000000' +
+  '111111110000000111111111000000111111111100000111111111110000' +
+  '111111111111000111111111111100111111111111110111111111111111' +
+  '111111100000000011111100000000001111100000000000111100000000' +
+  '000011100000000000001100000000000000100000000111111111111111' +
+  '111111101111111111111100111111111111100011111111111100001111' +
+  '111111100000111111111100000011111111100000001111111111111111' +
+  '011111111111111001111111111111000111111111111000011111111111' +
+  '000001111111111000000111111111000000011111111000000001111111' +
+  '000000000111111000000000011111000000000001111000000000000111' +
+  '000000000000011000000000000001000000011111111100000011111111' +
+  '110000011111111111000011111111111100011111111111110011111111' +
+  '111111011111111000000000000000000000010000000000000011000000' +
+  '000000011100000000000011110000000000011111000000000011111100' +
+  '000000011111110000000000000000100000000000000110000000000000' +
+  '111000000000000111100000000000111110000000000111111000000000' +
+  '111111100000000111111110000000111111111000000111111111100000' +
+  '111111111110000111111111111000111111111111100111111111111110' +
+  '011111100000000001111100000000000111100000000000011100000000' +
+  '000001100000000000000100000000000000000000000111111101111111' +
+  '111111100111111111111100011111111111100001111111111100000111' +
+  '111111100000011111111100000001111111100000000011111111111111' +
+  '001111111111111000111111111111000011111111111000001111111111' +
+  '000000111111111000000011111111000000001111111000000000111111' +
+  '000000000011111000000000001111000000000000111000000000000011' +
+  '000000000000001000000000000000233333333333333323333333333333' +
+  '332333333333333333233333333333333323333333333333332333333333' +
+  '333333233333333333333323333333333333332333333333333333233333' +
+  '333333333323333333333333332333333333333333233333333333333323' +
+  '333333333333332322222222222222232222222222222223222222222222' +
+  '222322222222222222232222222222222223222222222222222322222222' +
+  '222222232222222222222223222222222222222322222222222222232222' +
+  '222222222223222222222222222322222222222222232222222222222223' +
+  '322222233333333332222233333333333222233333333333322233333333' +
+  '333332233333333333333233333333333333333333333222222232222222' +
+  '222222233222222222222233322222222222233332222222222233333222' +
+  '222222233333322222222233333332222222233333333322222222222222' +
+  '332222222222222333222222222222333322222222222333332222222222' +
+  '333333222222222333333322222222333333332222222333333333222222' +
+  '333333333322222333333333332222333333333333222333333333333322' +
+  '333333333333332333333333333333333333322222222233333322222222' +
+  '223333322222222222333322222222222233322222222222223322222222' +
+  '222222322222222333333333333333333333323333333333333322333333' +
+  '333333322233333333333322223333333333322222333333333322222233' +
+  '333333322222223333333333333333233333333333333223333333333333' +
+  '222333333333333222233333333333222223333333333222222333333333' +
+  '222222233333333222222223333333222222222333333222222222233333' +
+  '222222222223333222222222222333222222222222233222222222222223' +
+  '222222233333333322222233333333332222233333333333222233333333' +
+  '333322233333333333332233333333333333233333333222222222222222' +
+  '222222232222222222222233222222222222233322222222222233332222' +
+  '222222233333222222222233333322222222233333332222222222222222' +
+  '322222222222222332222222222222333222222222222333322222222222' +
+  '333332222222222333333222222222333333322222222333333332222222' +
+  '333333333222222333333333322222333333333332222333333333333222' +
+  '333333333333322333333333333332233333322222222223333322222222' +
+  '222333322222222222233322222222222223322222222222222322222222' +
+  '222222222222222333333323333333333333322333333333333322233333' +
+  '333333322223333333333322222333333333322222233333333322222223' +
+  '333333322222222233333333333333223333333333333222333333333333' +
+  '222233333333333222223333333333222222333333333222222233333333' +
+  '222222223333333222222222333333222222222233333222222222223333' +
+  '222222222222333222222222222233222222222222223222222222222222';
+
+assertEq(expectedSummaryString.length, 9000); // stay sane
+
+assertEq(actualSummaryString, expectedSummaryString);
diff --git a/js/src/jit-test/tests/wasm/compiler-frame-depth.js b/js/src/jit-test/tests/wasm/compiler-frame-depth.js
new file mode 100644
index 0000000000..319755c609
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/compiler-frame-depth.js
@@ -0,0 +1,26 @@
+// Ensures that the postorder allows us to have very deep expression trees.
+
+var expr = '(local.get 0)';
+
+for (var i = 1000; i --> 0; ) {
+    expr = `(f32.neg ${expr})`;
+}
+
+var code = `(module
+ (func
+  (param f32)
+  (result f32)
+  ${expr}
+ )
+ (export "run" (func 0))
+)`;
+
+try {
+    wasmFullPass(code, Math.fround(13.37), {}, 13.37);
+} catch (e) {
+    // Some configurations, like e.g. ASAN, will fail these tests because its
+    // stack frames are much bigger than usual ones and the parser will bail
+    // out during its recursive descent.
+    // Ignore those errors specifically.
+    assertEq(e.message.includes('out of memory'), true);
+}
diff --git a/js/src/jit-test/tests/wasm/const.js b/js/src/jit-test/tests/wasm/const.js
new file mode 100644
index 0000000000..4b900398ef
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/const.js
@@ -0,0 +1,254 @@
+function testConst(type, str, expected) {
+    if (type === 'i64')
+        wasmFullPassI64(`(module (func $run (result i64) (i64.const ${str})))`, expected);
+    else
+        wasmFullPass(`(module (func (result ${type}) (${type}.const ${str})) (export "run" (func 0)))`, expected);
+}
+
+function testConstError(type, str) {
+  assertErrorMessage(() => wasmEvalText(`(module (func (result ${type}) (${type}.const ${str})) (export "" (func 0)))`).exports[""](), Error, /wasm text error/);
+}
+
+testConst('i32', '0', 0);
+testConst('i32', '-0', 0);
+testConst('i32', '23', 23);
+testConst('i32', '-23', -23);
+testConst('i32', '0x23', 35);
+testConst('i32', '-0x23', -35);
+testConst('i32', '2147483647', 2147483647);
+testConst('i32', '4294967295', -1);
+testConst('i32', '-2147483648', -2147483648);
+testConst('i32', '0x7fffffff', 2147483647);
+testConst('i32', '0x80000000', -2147483648);
+testConst('i32', '-0x80000000', -2147483648);
+testConst('i32', '0xffffffff', -1);
+
+testConst('i64', '0', 0);
+testConst('i64', '-0', 0);
+
+testConst('i64', '23', 23);
+testConst('i64', '-23', -23);
+
+testConst('i64', '0x23', 35);
+testConst('i64', '-0x23', -35);
+
+testConst('i64', '-0x1', -1);
+testConst('i64', '-1', -1);
+testConst('i64', '0xffffffffffffffff', -1);
+
+testConst('i64', '0xdeadc0de', 0xdeadc0de);
+testConst('i64', '0x1337c0de00000000', '0x1337c0de00000000');
+
+testConst('i64', '0x0102030405060708', '0x0102030405060708');
+testConst('i64', '-0x0102030405060708', '-0x0102030405060708');
+
+// INT64_MAX
+testConst('i64', '9223372036854775807', '0x7fffffffffffffff');
+testConst('i64', '0x7fffffffffffffff',  '0x7fffffffffffffff');
+
+// INT64_MAX + 1
+testConst('i64', '9223372036854775808', '0x8000000000000000');
+testConst('i64', '0x8000000000000000', '0x8000000000000000');
+
+// UINT64_MAX
+testConst('i64', '18446744073709551615', '0xffffffffffffffff');
+
+// INT64_MIN
+testConst('i64', '-9223372036854775808', '0x8000000000000000');
+testConst('i64', '-0x8000000000000000',  '0x8000000000000000');
+
+// INT64_MIN - 1
+testConstError('i64', '-9223372036854775809');
+
+testConstError('i64', '');
+testConstError('i64', '0.0');
+testConstError('i64', 'not an i64');
+
+testConst('f32', '0.0', 0.0);
+testConst('f32', '-0', -0.0);
+testConst('f32', '-0.0', -0.0);
+testConst('f32', '0x0.0', 0.0);
+testConst('f32', '-0x0.0', -0.0);
+testConst('f32', '-0x0', -0.0);
+testConst('f32', '0x0.0p0', 0.0);
+testConst('f32', '-0x0.0p0', -0.0);
+testConst('f32', 'inf', Infinity);
+testConst('f32', '-inf', -Infinity);
+testConst('f32', '+inf', Infinity);
+testConst('f32', 'nan', NaN);
+//testConst('f32', '-nan', NaN); // TODO: NYI
+testConst('f32', '+nan', NaN);
+//testConst('f32', 'nan:0x789', NaN); // TODO: NYI
+//testConst('f32', '-nan:0x789', NaN); // TODO: NYI
+//testConst('f32', '+nan:0x789', NaN); // TODO: NYI
+testConst('f32', '0x01p-149', 1.401298464324817e-45);
+testConst('f32', '0x1p-149', 1.401298464324817e-45);
+testConst('f32', '0x1p-150', 0);
+testConst('f32', '0x2p-150', 1.401298464324817e-45);
+testConst('f32', '0x1.2p-149', 1.401298464324817e-45);
+testConst('f32', '0x2.0p-149', 2.802596928649634e-45);
+testConst('f32', '0x2.2p-149', 2.802596928649634e-45);
+testConst('f32', '0x01p-148', 2.802596928649634e-45);
+testConst('f32', '0x0.1p-148', 0);
+testConst('f32', '0x0.1p-145', 1.401298464324817e-45);
+testConst('f32', '0x1p-148', 2.802596928649634e-45);
+testConst('f32', '0x1.111p-148', 2.802596928649634e-45);
+testConst('f32', '0x1.2p-148', 2.802596928649634e-45);
+testConst('f32', '0x2.0p-148', 5.605193857299268e-45);
+testConst('f32', '0x2.2p-148', 5.605193857299268e-45);
+testConst('f32', '0x1p-147', 5.605193857299268e-45);
+testConst('f32', '0x1p-126', 1.1754943508222875e-38);
+testConst('f32', '0x0.1fffffep+131', 3.4028234663852886e+38);
+testConst('f32', '0x1.fffffep+127', 3.4028234663852886e+38);
+testConstError('f32', '0x2.0p+127');
+testConstError('f32', '0x1.fffffep+128');
+testConst('f32', '0x0.1fffffep+128', 4.2535293329816107e+37);
+testConst('f32', '0x1p2', 4);
+testConst('f32', '0x10p2', 64);
+testConst('f32', '0x100p2', 1024);
+testConst('f32', '0x2p2', 8);
+testConst('f32', '0x4p2', 16);
+testConst('f32', '0x1p3', 8);
+testConst('f32', '0x1p4', 16);
+testConst('f32', '-0x1p+3', -8);
+testConst('f32', '0x3p-2', .75);
+testConst('f32', '-0x76.54p-32', -2.7550413506105542e-8);
+testConst('f32', '0xf.ffffffffffffffffp+123', 170141183460469231731687303715884105728);
+testConstError('f32', '0xf.ffffffffffffffffp+124');
+testConst('f32', '1.1754943508222875e-38', 1.1754943508222875e-38);
+testConst('f32', '3.4028234663852886e+38', 3.4028234663852886e+38);
+testConst('f32', '1.1754943508222875e-35', 1.1754943508222875e-35);
+testConst('f32', '3.4028234663852886e+35', 3.4028234346940236e+35);
+testConst('f32', '1.1754943508222875e-30', 1.1754943508222875e-30);
+testConst('f32', '3.4028234663852886e+30', 3.4028233462973677e+30);
+testConst('f32', '4.0', 4);
+testConst('f32', '-8.', -8);
+testConst('f32', '-2.7550413506105542e-8', -2.7550413506105542e-8);
+testConst('f32', '2.138260e+05', 2.138260e+05);
+testConst('f32', '3.891074380317903e-33', 3.891074380317903e-33);
+testConst('f32', '-9465807272673280.0', -9465807272673280);
+testConst('f32', '1076.1376953125', 1076.1376953125);
+testConst('f32', '-13364.1376953125', -13364.1376953125);
+testConst('f32', '4.133607864379883', 4.133607864379883);
+testConst('f32', '2.0791168212890625', 2.0791168212890625);
+testConst('f32', '0.000002414453774690628', 0.000002414453774690628);
+testConst('f32', '0.5312881469726562', 0.5312881469726562);
+testConst('f32', '5.570960e+05', 5.570960e+05);
+testConst('f32', '5.066758603788912e-7', 5.066758603788912e-7);
+testConst('f32', '-5.066758603788912e-7', -5.066758603788912e-7);
+testConst('f32', '1.875000e-01', 1.875000e-01);
+testConst('f32', '-0x1.b021fb98e9a17p-104', -8.322574059965897e-32);
+testConst('f32', '0x1.08de5bf3f784cp-129', 1.5202715065429227e-39);
+testConstError('f32', '0x1.d50b969fbbfb3p+388');
+testConst('f32', '0x3434.2p4', 2.138260e+05);
+testConst('f32', '0x1434.2p-120', 3.891074380317903e-33);
+testConst('f32', '-0x0434.234p43', -9465807272673280);
+testConst('f32', '0x0434.234p0', 1076.1376953125);
+testConst('f32', '-0x3434.234p0', -13364.1376953125);
+testConst('f32', '0x4.22342p0', 4.133607864379883);
+testConst('f32', '0x30000p-20', 1.875000e-01);
+testConst('f32', '0x0.533fcccp-125', 7.645233588931088e-39);
+testConst('f32', '0', 0);
+
+testConst('f64', '0.0', 0.0);
+testConst('f64', '-0.0', -0.0);
+testConst('f64', '-0', -0.0);
+testConst('f64', '0x0.0', 0.0);
+testConst('f64', '-0x0.0', -0.0);
+testConst('f64', '-0x0', -0.0);
+testConst('f64', '0x0.0p0', 0.0);
+testConst('f64', '-0x0.0p0', -0.0);
+testConst('f64', 'inf', Infinity);
+testConst('f64', '-inf', -Infinity);
+testConst('f64', '+inf', Infinity);
+testConst('f64', 'nan', NaN);
+//testConst('f64', '-nan', NaN); // TODO: NYI
+testConst('f64', '+nan', NaN);
+//testConst('f64', 'nan:0x789', NaN); // TODO: NYI
+//testConst('f64', '-nan:0x789', NaN); // TODO: NYI
+//testConst('f64', '+nan:0x789', NaN); // TODO: NYI
+testConst('f64', '0x01p-149', 1.401298464324817e-45);
+testConst('f64', '0x1p-149', 1.401298464324817e-45);
+testConst('f64', '0x1p-150', 7.006492321624085e-46);
+testConst('f64', '0x2p-150', 1.401298464324817e-45);
+testConst('f64', '0x1.2p-149', 1.5764607723654192e-45);
+testConst('f64', '0x2.0p-149', 2.802596928649634e-45);
+testConst('f64', '0x2.2p-149', 2.977759236690236e-45);
+testConst('f64', '0x01p-148', 2.802596928649634e-45);
+testConst('f64', '0x0.1p-148', 1.7516230804060213e-46);
+testConst('f64', '0x0.1p-145', 1.401298464324817e-45);
+testConst('f64', '0x1p-148', 2.802596928649634e-45);
+testConst('f64', '0x1.111p-148', 2.9893911087085575e-45);
+testConst('f64', '0x1.2p-148', 3.1529215447308384e-45);
+testConst('f64', '0x2.0p-148', 5.605193857299268e-45);
+testConst('f64', '0x2.2p-148', 5.955518473380473e-45);
+testConst('f64', '0x1p-147', 5.605193857299268e-45);
+testConst('f64', '0x1p-126', 1.1754943508222875e-38);
+testConst('f64', '0x0.1fffffep+131', 3.4028234663852886e+38);
+testConst('f64', '0x1.fffffep+127', 3.4028234663852886e+38);
+testConst('f64', '0x2.0p+127', 3.402823669209385e+38);
+testConst('f64', '0x1.fffffep+128', 6.805646932770577e+38);
+testConst('f64', '0x0.1fffffep+128', 4.2535293329816107e+37);
+testConst('f64', '0x1p2', 4);
+testConst('f64', '0x10p2', 64);
+testConst('f64', '0x100p2', 1024);
+testConst('f64', '0x2p2', 8);
+testConst('f64', '0x4p2', 16);
+testConst('f64', '0x1p3', 8);
+testConst('f64', '0x1p4', 16);
+testConst('f64', '-0x1p+3', -8);
+testConst('f64', '0x3p-2', .75);
+testConst('f64', '-0x76.54p-32', -2.7550413506105542e-8);
+testConst('f64', '1.1754943508222875e-38', 1.1754943508222875e-38);
+testConst('f64', '3.4028234663852886e+38', 3.4028234663852886e+38);
+testConst('f64', '1.1754943508222875e-35', 1.1754943508222875e-35);
+testConst('f64', '3.4028234663852886e+35', 3.4028234663852886e+35);
+testConst('f64', '1.1754943508222875e-30', 1.1754943508222875e-30);
+testConst('f64', '3.4028234663852886e+30', 3.402823466385289e+30);
+testConst('f64', '4.0', 4);
+testConst('f64', '-8.', -8);
+testConst('f64', '-2.7550413506105542e-8', -2.7550413506105542e-8);
+testConst('f64', '2.138260e+05', 2.138260e+05);
+testConst('f64', '3.891074380317903e-33', 3.891074380317903e-33);
+testConst('f64', '-9465807272673280.0', -9465807272673280);
+testConst('f64', '1076.1376953125', 1076.1376953125);
+testConst('f64', '-13364.1376953125', -13364.1376953125);
+testConst('f64', '4.133607864379883', 4.133607864379883);
+testConst('f64', '2.0791168212890625', 2.0791168212890625);
+testConst('f64', '0.000002414453774690628', 0.000002414453774690628);
+testConst('f64', '0.5312881469726562', 0.5312881469726562);
+testConst('f64', '5.570960e+05', 5.570960e+05);
+testConst('f64', '5.066758603788912e-7', 5.066758603788912e-7);
+testConst('f64', '-5.066758603788912e-7', -5.066758603788912e-7);
+testConst('f64', '1.875000e-01', 1.875000e-01);
+testConst('f64', '0x3434.2p4', 2.138260e+05);
+testConst('f64', '0x1434.2p-120', 3.891074380317903e-33);
+testConst('f64', '-0x0434.234p43', -9465807272673280);
+testConst('f64', '0x0434.234p0', 1076.1376953125);
+testConst('f64', '-0x3434.234p0', -13364.1376953125);
+testConst('f64', '0x4.22342p0', 4.133607864379883);
+testConst('f64', '0x4.2882000p-1', 2.0791168212890625);
+testConst('f64', '0x30000p-20', 1.875000e-01);
+testConst('f64', '0x2f05.000bef2113p-1036', 1.634717678224908e-308);
+testConst('f64', '0x24c6.004d0deaa3p-1036', 1.2784941357502007e-308);
+testConst('f64', '0', 0);
+
+testConstError('i32', '');
+testConstError('i32', '0.0');
+testConstError('i32', 'not an i32');
+testConstError('i32', '4294967296');
+testConstError('i32', '-2147483649');
+
+testConstError('f32', '');
+testConstError('f32', 'not an f32');
+testConstError('f32', 'nan:');
+testConstError('f32', 'nan:0');
+testConstError('f32', 'nan:0x');
+testConstError('f32', 'nan:0x0');
+
+testConstError('f64', '');
+testConstError('f64', 'not an f64');
+testConstError('f64', 'nan:');
+testConstError('f64', 'nan:0');
+testConstError('f64', 'nan:0x');
+testConstError('f64', 'nan:0x0');
diff --git a/js/src/jit-test/tests/wasm/control-flow-phi-inputs.js b/js/src/jit-test/tests/wasm/control-flow-phi-inputs.js
new file mode 100644
index 0000000000..4e3fb23286
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/control-flow-phi-inputs.js
@@ -0,0 +1,80 @@
+// Test the triangle pattern where the phi-input doesn't match the initial input.
+//
+//       initialBlock
+//         /     \
+// trueBranch     |
+//         \     /
+//    phiBlock+falseBranch
+//            |
+//        testBlock
+//
+// Also see bug 1768346.
+
+var f = wasmEvalText(`(module
+  (func (result i32)
+    block (result i32)
+      i32.const 0 ;; This must flow into the if below.
+      i32.const 1
+      br_if 0
+      drop
+      i32.const 1
+    end
+    if
+      i32.const 100
+      return
+    end
+    i32.const 200
+  )
+  (export "" (func 0))
+)`).exports[""];
+
+assertEq(f(), 200);
+
+var g = wasmEvalText(`(module
+  (func (result i32)
+    block (result i32)
+      i32.const 0 ;; This must flow into the if below.
+      i32.const 1
+      br_if 0
+      drop
+      i32.const 1 ;; This must flow into the if below
+      i32.const 1
+      br_if 0
+      drop
+      i32.const 1
+    end
+    if
+      i32.const 100
+      return
+    end
+    i32.const 200
+  )
+  (export "" (func 0))
+)`).exports[""];
+
+assertEq(g(), 200);
+
+var h = wasmEvalText(`(module
+  (func (param i32) (result i32)
+    block (result i32)
+      local.get 0 ;; This must flow into the if below.
+      local.get 0
+      br_if 0
+      drop
+      i32.const 0 ;; This must flow into the if below
+      i32.const 1
+      br_if 0
+      drop
+      i32.const 1
+    end
+    if
+      i32.const 100
+      return
+    end
+    i32.const 200
+  )
+  (export "" (func 0))
+)`).exports[""];
+
+assertEq(h(0), 200);
+assertEq(h(1), 100);
diff --git a/js/src/jit-test/tests/wasm/control-flow.js b/js/src/jit-test/tests/wasm/control-flow.js
new file mode 100644
index 0000000000..2937206dd3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/control-flow.js
@@ -0,0 +1,673 @@
+const RuntimeError = WebAssembly.RuntimeError;
+
+// ----------------------------------------------------------------------------
+// if
+
+// Condition is an int32
+wasmFailValidateText('(module (func (local f32) (if (local.get 0) (i32.const 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (local f32) (if (local.get 0) (i32.const 1) (i32.const 0))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (local f64) (if (local.get 0) (i32.const 1) (i32.const 0))))', mismatchError("f64", "i32"));
+wasmEvalText('(module (func (local i32) (if (local.get 0) (nop))) (export "" (func 0)))');
+wasmEvalText('(module (func (local i32) (if (local.get 0) (nop) (nop))) (export "" (func 0)))');
+
+// Expression values types are consistent
+// Also test that we support (result t) for `if`
+wasmFailValidateText('(module (func (result i32) (local f32) (if (result f32) (i32.const 42) (local.get 0) (i32.const 0))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (result i32) (local f64) (if (result i32) (i32.const 42) (i32.const 0) (local.get 0))))', mismatchError("f64", "i32"));
+wasmFailValidateText('(module (func (result i64) (if (result i64) (i32.const 0) (i32.const 1) (i32.const 2))))', mismatchError("i32", "i64"));
+assertEq(wasmEvalText('(module (func (result i32) (if (result i32) (i32.const 42) (i32.const 1) (i32.const 2))) (export "" (func 0)))').exports[""](), 1);
+assertEq(wasmEvalText('(module (func (result i32) (if (result i32) (i32.const 0) (i32.const 1) (i32.const 2))) (export "" (func 0)))').exports[""](), 2);
+
+// Even if we don't yield, sub expressions types still have to match.
+wasmFailValidateText('(module (func (param f32) (if (result i32) (i32.const 42) (i32.const 1) (local.get 0))) (export "" (func 0)))', mismatchError('f32', 'i32'));
+wasmFailValidateText('(module (func (if (result i32) (i32.const 42) (i32.const 1) (i32.const 0))) (export "" (func 0)))', /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+wasmFullPass('(module (func (drop (if (result i32) (i32.const 42) (i32.const 1) (i32.const 0)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (param f32) (if (i32.const 42) (drop (i32.const 1)) (drop (local.get 0)))) (export "run" (func 0)))', undefined, {}, 13.37);
+
+// Sub-expression values are returned
+// Also test that we support (result t) for `block`
+wasmFullPass(`(module
+    (func
+        (result i32)
+        (if (result i32)
+            (i32.const 42)
+            (block (result i32)
+                (
+                    if (result i32)
+                    (block (result i32)
+                        (drop (i32.const 3))
+                        (drop (i32.const 5))
+                        (i32.const 0)
+                    )
+                    (i32.const 1)
+                    (i32.const 2)
+                )
+            )
+            (i32.const 0)
+        )
+    )
+    (export "run" (func 0))
+)`, 2);
+
+// The if (resp. else) branch is taken iff the condition is true (resp. false)
+counter = 0;
+var imports = { "":{inc() { counter++ }} };
+wasmFullPass(`(module
+    (import "" "inc" (func (result i32)))
+    (func
+        (result i32)
+        (if (result i32)
+            (i32.const 42)
+            (i32.const 1)
+            (call 0)
+        )
+    )
+    (export "run" (func 1))
+)`, 1, imports);
+assertEq(counter, 0);
+
+wasmFullPass(`(module
+    (import "" "inc" (func (result i32)))
+    (func
+        (result i32)
+        (if (result i32)
+            (i32.const 0)
+            (call 0)
+            (i32.const 1)
+        )
+    )
+    (export "run" (func 1))
+)`, 1, imports);
+assertEq(counter, 0);
+
+wasmFullPass(`(module
+    (import "" "inc" (func (result i32)))
+    (func
+        (if
+            (i32.const 0)
+            (drop (call 0))
+        )
+    )
+    (export "run" (func 1))
+)`, undefined, imports);
+assertEq(counter, 0);
+
+assertEq(wasmEvalText(`(module
+    (import "" "inc" (func (result i32)))
+    (func
+        (if
+            (i32.const 1)
+            (drop (call 0))
+        )
+    )
+    (export "" (func 1))
+)`, imports).exports[""](), undefined);
+assertEq(counter, 1);
+
+wasmFullPass(`(module
+    (func
+        (result i32)
+        (if (result i32)
+            (i32.const 0)
+            (br 0 (i32.const 0))
+            (br 0 (i32.const 1))
+        )
+    )
+    (export "run" (func 0))
+)`, 1);
+assertEq(counter, 1);
+
+wasmFullPass(`(module
+    (func
+        (if
+            (i32.const 1)
+            (br 0)
+        )
+    )
+    (export "run" (func 0))
+)`, undefined);
+assertEq(counter, 1);
+
+// One can chain if with if/if
+counter = 0;
+wasmFullPass(`(module
+    (import "" "inc" (func (result i32)))
+    (func
+        (result i32)
+        (if (result i32)
+            (i32.const 1)
+            (if (result i32)
+                (i32.const 2)
+                (if (result i32)
+                    (i32.const 3)
+                    (if (result i32)
+                        (i32.const 0)
+                        (call 0)
+                        (i32.const 42)
+                    )
+                    (call 0)
+                )
+                (call 0)
+            )
+            (call 0)
+        )
+    )
+    (export "run" (func 1))
+)`, 42, imports);
+assertEq(counter, 0);
+
+// "if" doesn't return an expression value
+wasmFailValidateText('(module (func (result i32) (if (result i32) (i32.const 42) (i32.const 0))))', /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+wasmFailValidateText('(module (func (result i32) (if (result i32) (i32.const 42) (drop (i32.const 0)))))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (if (result i32) (i32.const 1) (i32.const 0) (if (result i32) (i32.const 1) (i32.const 1)))))', /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+wasmFailValidateText('(module (func (result i32) (if (result i32) (i32.const 1) (drop (i32.const 0)) (if (i32.const 1) (drop (i32.const 1))))))', emptyStackError);
+wasmFailValidateText('(module (func (if (result i32) (i32.const 1) (i32.const 0) (if (result i32) (i32.const 1) (i32.const 1)))))', /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+wasmFailValidateText('(module (func (if (result i32) (i32.const 1) (i32.const 0) (if (i32.const 1) (drop (i32.const 1))))))', emptyStackError);
+wasmFailValidateText('(module (func (if (i32.const 1) (drop (i32.const 0)) (if (result i32) (i32.const 1) (i32.const 1)))))', /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+wasmEvalText('(module (func (if (i32.const 1) (drop (i32.const 0)) (if (i32.const 1) (drop (i32.const 1))))))');
+
+// ----------------------------------------------------------------------------
+// return
+
+wasmFullPass('(module (func (return)) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (result i32) (return (i32.const 1))) (export "run" (func 0)))', 1);
+wasmFailValidateText('(module (func (if (return) (i32.const 0))) (export "run" (func 0)))', unusedValuesError);
+wasmFailValidateText('(module (func (result i32) (return)) (export "" (func 0)))', emptyStackError);
+wasmFullPass('(module (func (return (i32.const 1))) (export "run" (func 0)))', undefined);
+wasmFailValidateText('(module (func (result f32) (return (i32.const 1))) (export "" (func 0)))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (result i32) (return)) (export "" (func 0)))', emptyStackError);
+
+// ----------------------------------------------------------------------------
+// br / br_if
+
+wasmFailValidateText('(module (func (result i32) (block (br 0))) (export "" (func 0)))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (br 0)) (export "" (func 0)))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (block (br_if 0 (i32.const 0)))) (export "" (func 0)))', emptyStackError);
+
+const DEPTH_OUT_OF_BOUNDS = /(branch depth exceeds current nesting level)|(branch depth too large)/;
+
+wasmFailValidateText('(module (func (br 1)))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (block (br 2))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (loop (br 2))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (if (i32.const 0) (br 2))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (if (i32.const 0) (br 1) (br 2))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (if (i32.const 0) (br 2) (br 1))))', DEPTH_OUT_OF_BOUNDS);
+
+wasmFailValidateText('(module (func (br_if 1 (i32.const 0))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (block (br_if 2 (i32.const 0)))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (loop (br_if 2 (i32.const 0)))))', DEPTH_OUT_OF_BOUNDS);
+
+wasmFailValidateText(`(module (func (result i32)
+  block
+    br 0
+    if
+      i32.const 0
+      i32.const 2
+    end
+  end
+) (export "" (func 0)))`, unusedValuesError);
+
+wasmFullPass(`(module (func (block $out (br_if $out (br 0)))) (export "run" (func 0)))`, undefined);
+
+wasmFullPass('(module (func (br 0)) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block (br 0))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block $l (br $l))) (export "run" (func 0)))', undefined);
+
+wasmFullPass('(module (func (block (block (br 1)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block $l (block (br $l)))) (export "run" (func 0)))', undefined);
+
+wasmFullPass('(module (func (block $l (block $m (br $l)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block $l (block $m (br $m)))) (export "run" (func 0)))', undefined);
+
+wasmFullPass(`(module (func (result i32)
+  (block
+    (br 0)
+    (return (i32.const 0))
+  )
+  (return (i32.const 1))
+) (export "run" (func 0)))`, 1);
+
+wasmFullPass(`(module (func (result i32)
+  (block
+    (block
+      (br 0)
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+  (return (i32.const 2))
+) (export "run" (func 0)))`, 1);
+
+wasmFullPass(`(module (func (result i32)
+  (block $outer
+    (block $inner
+      (br $inner)
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+  (return (i32.const 2))
+) (export "run" (func 0)))`, 1);
+
+var notcalled = false;
+var called = false;
+var imports = {"": {
+    notcalled() {notcalled = true},
+    called() {called = true}
+}};
+wasmFullPass(`(module
+(import "" "notcalled" (func))
+(import "" "called" (func))
+(func
+  (block
+    (return (br 0))
+    (call 0)
+  )
+  (call 1)
+) (export "run" (func 2)))`, undefined, imports);
+assertEq(notcalled, false);
+assertEq(called, true);
+
+wasmFullPass(`(module (func
+  (block
+    (i32.add
+      (i32.const 0)
+      (return (br 0))
+    )
+    drop
+  )
+  (return)
+) (export "run" (func 0)))`, undefined);
+
+wasmFullPass(`(module (func (result i32)
+  (block
+    (if
+      (i32.const 1)
+      (br 0)
+      (return (i32.const 0))
+    )
+  )
+  (return (i32.const 1))
+) (export "run" (func 0)))`, 1);
+
+wasmFullPass('(module (func (br_if 0 (i32.const 1))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (br_if 0 (i32.const 0))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block (br_if 0 (i32.const 1)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block (br_if 0 (i32.const 0)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block $l (br_if $l (i32.const 1)))) (export "run" (func 0)))', undefined);
+
+var isNonZero = wasmEvalText(`(module (func (param i32) (result i32)
+  (block
+    (br_if 0 (local.get 0))
+    (return (i32.const 0))
+  )
+  (return (i32.const 1))
+) (export "" (func 0)))`).exports[""];
+
+assertEq(isNonZero(0), 0);
+assertEq(isNonZero(1), 1);
+assertEq(isNonZero(-1), 1);
+
+// branches with values
+// br/br_if and block
+wasmFailValidateText('(module (func (result i32) (br 0)))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (br 0 (f32.const 42))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (result i32) (block (br 0))))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (block (result f32) (br 0 (f32.const 42)))))', mismatchError("f32", "i32"));
+
+wasmFailValidateText(`(module (func (param i32) (result i32) (block (if (result i32) (local.get 0) (br 0 (i32.const 42))))) (export "" (func 0)))`, /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+wasmFailValidateText(`(module (func (param i32) (result i32) (block (result i32) (if (local.get 0) (drop (i32.const 42))) (br 0 (f32.const 42)))) (export "" (func 0)))`, mismatchError("f32", "i32"));
+
+wasmFullPass('(module (func (result i32) (br 0 (i32.const 42)) (i32.const 13)) (export "run" (func 0)))', 42);
+wasmFullPass('(module (func (result i32) (block (result i32) (br 0 (i32.const 42)) (i32.const 13))) (export "run" (func 0)))', 42);
+
+wasmFailValidateText('(module (func) (func (block (result i32) (br 0 (call 0)) (i32.const 13))) (export "" (func 0)))', emptyStackError);
+wasmFailValidateText('(module (func) (func (block (result i32) (br_if 0 (call 0) (i32.const 1)) (i32.const 13))) (export "" (func 0)))', emptyStackError);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (block (result i32) (if (local.get 0) (drop (i32.const 42))) (i32.const 43))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 43);
+
+wasmFailValidateText(`(module (func (param i32) (result i32) (block (result i32) (if (result i32) (local.get 0) (br 0 (i32.const 42))) (i32.const 43))) (export "" (func 0)))`, /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (block (result i32) (if (local.get 0) (br 1 (i32.const 42))) (i32.const 43))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 42);
+
+wasmFailValidateText(`(module (func (param i32) (result i32) (block (br_if 0 (i32.const 42) (local.get 0)) (i32.const 43))) (export "" (func 0)))`, /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (block (result i32) (drop (br_if 0 (i32.const 42) (local.get 0))) (i32.const 43))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 42);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (block (result i32) (if (local.get 0) (drop (i32.const 42))) (br 0 (i32.const 43)))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 43);
+
+wasmFailValidateText(`(module (func (param i32) (result i32) (block (result i32) (if (result i32) (local.get 0) (br 0 (i32.const 42))) (br 0 (i32.const 43)))) (export "" (func 0)))`, /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (if (local.get 0) (br 1 (i32.const 42))) (br 0 (i32.const 43))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 42);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (block (result i32) (if (local.get 0) (br 1 (i32.const 42))) (br 0 (i32.const 43)))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 42);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (br_if 0 (i32.const 42) (local.get 0)) (br 0 (i32.const 43))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 42);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (block (result i32) (br_if 0 (i32.const 42) (local.get 0)) (br 0 (i32.const 43)))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 43);
+assertEq(f(1), 42);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (i32.add (i32.const 1) (block (result i32) (if (local.get 0) (drop (i32.const 99))) (i32.const -1)))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 0);
+assertEq(f(1), 0);
+
+wasmFailValidateText(`(module (func (param i32) (result i32) (i32.add (i32.const 1) (block (result i32) (if (result i32) (local.get 0) (br 0 (i32.const 99))) (i32.const -1)))) (export "" (func 0)))`, /(if without else with a result value)|(type mismatch: expected i32 but nothing on stack)/);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (i32.add (i32.const 1) (block (result i32) (if (local.get 0) (br 1 (i32.const 99))) (i32.const -1)))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 0);
+assertEq(f(1), 100);
+
+wasmFailValidateText(`(module (func (param i32) (result i32) (i32.add (i32.const 1) (block (br_if 0 (i32.const 99) (local.get 0)) (i32.const -1)))) (export "" (func 0)))`, /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32) (i32.add (i32.const 1) (block (result i32) (drop (br_if 0 (i32.const 99) (local.get 0))) (i32.const -1)))) (export "" (func 0)))`).exports[""];
+assertEq(f(0), 0);
+assertEq(f(1), 100);
+
+wasmFullPass(`(module (func (result i32) (block (result i32) (br 0 (return (i32.const 42))) (i32.const 0))) (export "run" (func 0)))`, 42);
+wasmFullPass(`(module (func (result i32) (block (result i32) (return (br 0 (i32.const 42))))) (export "run" (func 0)))`, 42);
+wasmFullPass(`(module (func (result i32) (block (result i32) (return (br 0 (i32.const 42))) (i32.const 0))) (export "run" (func 0)))`, 42);
+
+wasmFullPass(`(module (func (result f32) (drop (block (result i32) (br 0 (i32.const 0)))) (block (result f32) (br 0 (f32.const 42)))) (export "run" (func 0)))`, 42);
+
+var called = 0;
+var imports = {
+    sideEffects: {
+        ifTrue(x) {assertEq(x, 13); called++;},
+        ifFalse(x) {assertEq(x, 37); called--;}
+    }
+}
+var f = wasmEvalText(`(module
+ (import "sideEffects" "ifTrue" (func (param i32)))
+ (import "sideEffects" "ifFalse" (func (param i32)))
+ (func
+  (param i32) (result i32)
+  (block $outer
+   (if
+    (local.get 0)
+    (block (call 0 (i32.const 13)) (br $outer))
+   )
+   (if
+    (i32.eqz (local.get 0))
+    (block (call 1 (i32.const 37)) (br $outer))
+   )
+  )
+  (i32.const 42)
+ )
+(export "" (func 2)))`, imports).exports[""];
+assertEq(f(0), 42);
+assertEq(called, -1);
+assertEq(f(1), 42);
+assertEq(called, 0);
+
+// br/br_if and loop
+wasmFullPass(`(module (func (param i32) (result i32) (block $out (result i32) (loop $in (result i32) (br $out (local.get 0))))) (export "run" (func 0)))`, 1, {}, 1);
+wasmFullPass(`(module (func (param i32) (result i32) (loop $in (result i32) (br 1 (local.get 0)))) (export "run" (func 0)))`, 1, {}, 1);
+wasmFullPass(`(module (func (param i32) (result i32) (block $out (result i32) (loop $in (result i32) (br $out (local.get 0))))) (export "run" (func 0)))`, 1, {}, 1);
+
+wasmFailValidateText(`(module (func (param i32) (result i32)
+  (block $out
+   (loop $in
+    (if (local.get 0) (br $in (i32.const 1)))
+    (if (local.get 0) (br $in (f32.const 2)))
+    (if (local.get 0) (br $in (f64.const 3)))
+    (if (local.get 0) (br $in))
+    (i32.const 7)
+   )
+  )
+) (export "" (func 0)))`, /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+wasmFullPass(`(module
+ (func
+  (result i32)
+  (local i32)
+  (block $out (result i32)
+    (loop $in (result i32)
+     (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+     (if
+        (i32.ge_s (local.get 0) (i32.const 7))
+        (br $out (local.get 0))
+     )
+     (br $in)
+    )
+  )
+ )
+(export "run" (func 0)))`, 7);
+
+wasmFullPass(`(module
+ (func
+  (result i32)
+  (local i32)
+  (block $out (result i32)
+   (loop $in (result i32)
+    (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+    (br_if $out (local.get 0) (i32.ge_s (local.get 0) (i32.const 7)))
+    (br $in)
+   )
+  )
+ )
+(export "run" (func 0)))`, 7);
+
+// ----------------------------------------------------------------------------
+// loop
+
+wasmFailValidateText('(module (func (loop (br 2))))', DEPTH_OUT_OF_BOUNDS);
+
+wasmFailValidateText('(module (func (result i32) (drop (loop (i32.const 2))) (i32.const 1)) (export "" (func 0)))', /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+wasmFullPass('(module (func (loop)) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (result i32) (loop (drop (i32.const 2))) (i32.const 1)) (export "run" (func 0)))', 1);
+
+wasmFullPass('(module (func (loop (br 1))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (loop $a (br 1))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (loop $a (br_if $a (i32.const 0)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (block $a (loop $b (br $a)))) (export "run" (func 0)))', undefined);
+wasmFullPass('(module (func (result i32) (loop (result i32) (i32.const 1))) (export "run" (func 0)))', 1);
+
+wasmFullPass(`(module (func (result i32) (local i32)
+  (block
+    $break
+    (loop
+      $continue
+      (if
+        (i32.gt_u (local.get 0) (i32.const 5))
+        (br $break)
+      )
+      (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+      (br $continue)
+    )
+  )
+  (return (local.get 0))
+) (export "run" (func 0)))`, 6);
+
+wasmFullPass(`(module (func (result i32) (local i32)
+  (block
+    $break
+    (loop
+      $continue
+      (br_if
+        $break
+        (i32.gt_u (local.get 0) (i32.const 5))
+      )
+      (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+      (br $continue)
+    )
+  )
+  (return (local.get 0))
+) (export "run" (func 0)))`, 6);
+
+wasmFullPass(`(module (func (result i32) (local i32)
+  (block
+    $break
+    (loop
+      $continue
+      (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+      (br_if
+        $continue
+        (i32.le_u (local.get 0) (i32.const 5))
+      )
+    )
+  )
+  (return (local.get 0))
+) (export "run" (func 0)))`, 6);
+
+wasmFullPass(`(module (func (result i32) (local i32)
+  (block
+    $break
+    (loop
+      $continue
+      (br_if
+        $break
+        (i32.gt_u (local.get 0) (i32.const 5))
+      )
+      (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+      (loop
+        (br $continue)
+      )
+      (return (i32.const 42))
+    )
+  )
+  (return (local.get 0))
+) (export "run" (func 0)))`, 6);
+
+wasmFullPass(`(module (func (result i32) (local i32)
+  (block
+    $break
+    (loop
+      $continue
+      (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+      (loop
+        (br_if
+          $continue
+          (i32.le_u (local.get 0) (i32.const 5))
+        )
+      )
+      (br $break)
+    )
+  )
+  (return (local.get 0))
+) (export "run" (func 0)))`, 6);
+
+// ----------------------------------------------------------------------------
+// br_table
+
+wasmFailValidateText('(module (func (br_table 1 (i32.const 0))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (br_table 1 0 (i32.const 0))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (br_table 0 1 (i32.const 0))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (block (br_table 2 0 (i32.const 0)))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (block (br_table 0 2 (i32.const 0)))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (block (br_table 0 (f32.const 0)))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (loop (br_table 2 0 (i32.const 0)))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (loop (br_table 0 2 (i32.const 0)))))', DEPTH_OUT_OF_BOUNDS);
+wasmFailValidateText('(module (func (loop (br_table 0 (f32.const 0)))))', mismatchError("f32", "i32"));
+
+wasmFullPass(`(module (func (param i32) (result i32)
+  (block $default
+   (br_table $default (local.get 0))
+   (return (i32.const 0))
+  )
+  (return (i32.const 1))
+) (export "run" (func 0)))`, 1);
+
+wasmFullPass(`(module (func (param i32) (result i32)
+  (block $default
+   (br_table $default (return (i32.const 1)))
+   (return (i32.const 0))
+  )
+  (return (i32.const 2))
+) (export "run" (func 0)))`, 1);
+
+wasmFullPass(`(module (func (param i32) (result i32)
+  (block $outer
+   (block $inner
+    (br_table $inner (local.get 0))
+    (return (i32.const 0))
+   )
+   (return (i32.const 1))
+  )
+  (return (i32.const 2))
+) (export "run" (func 0)))`, 1);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32)
+  (block $0
+   (block $1
+    (block $2
+     (block $default
+      (br_table $0 $1 $2 $default (local.get 0))
+     )
+     (return (i32.const -1))
+    )
+    (return (i32.const 2))
+   )
+  )
+  (return (i32.const 0))
+) (export "" (func 0)))`).exports[""];
+
+assertEq(f(-2), -1);
+assertEq(f(-1), -1);
+assertEq(f(0), 0);
+assertEq(f(1), 0);
+assertEq(f(2), 2);
+assertEq(f(3), -1);
+
+// br_table with values
+wasmFailValidateText('(module (func (result i32) (block (result i32) (br_table 0 (i32.const 0)))))', emptyStackError);
+wasmFailValidateText('(module (func (result i32) (block (result i32) (br_table 0 (f32.const 0) (i32.const 0)))))', mismatchError("f32", "i32"));
+
+wasmFailValidateText(`(module
+ (func
+  (result i32)
+  (block $outer (result f32)
+   (block $inner (result f32)
+    (br_table $outer $inner (f32.const 13.37) (i32.const 1))
+   )
+   (br $outer (i32.const 42))
+  )
+ )
+(export "" (func 0)))`, mismatchError("i32", "f32"));
+
+wasmFullPass(`(module (func (result i32) (block $default (result i32) (br_table $default (i32.const 42) (i32.const 1)))) (export "run" (func 0)))`, 42);
+
+var f = wasmEvalText(`(module (func (param i32) (result i32)
+  (i32.add
+   (block $1 (result i32)
+    (drop (block $0 (result i32)
+     (drop (block $default (result i32)
+      (br_table $0 $1 $default (local.get 0) (local.get 0))
+     ))
+     (tee_local 0 (i32.mul (i32.const 2) (local.get 0)))
+    ))
+    (tee_local 0 (i32.add (i32.const 4) (local.get 0)))
+   )
+   (i32.const 1)
+  )
+ ) (export "" (func 0)))`).exports[""];
+
+assertEq(f(0), 5);
+assertEq(f(1), 2);
+assertEq(f(2), 9);
+assertEq(f(3), 11);
+assertEq(f(4), 13);
+
+// ----------------------------------------------------------------------------
+// unreachable
+
+const UNREACHABLE = /unreachable/;
+assertErrorMessage(wasmEvalText(`(module (func (unreachable)) (export "" (func 0)))`).exports[""], RuntimeError, UNREACHABLE);
+assertErrorMessage(wasmEvalText(`(module (func (if (unreachable) (nop))) (export "" (func 0)))`).exports[""], RuntimeError, UNREACHABLE);
+assertErrorMessage(wasmEvalText(`(module (func (block (br_if 0 (unreachable)))) (export "" (func 0)))`).exports[""], RuntimeError, UNREACHABLE);
+assertErrorMessage(wasmEvalText(`(module (func (block (br_table 0 (unreachable)))) (export "" (func 0)))`).exports[""], RuntimeError, UNREACHABLE);
+assertErrorMessage(wasmEvalText(`(module (func (result i32) (i32.add (i32.const 0) (unreachable))) (export "" (func 0)))`).exports[""], RuntimeError, UNREACHABLE);
diff --git a/js/src/jit-test/tests/wasm/conversion.js b/js/src/jit-test/tests/wasm/conversion.js
new file mode 100644
index 0000000000..cc1ff7f8f6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/conversion.js
@@ -0,0 +1,396 @@
+function testConversion0(resultType, opcode, paramType, op, expect) {
+    if (resultType === 'i64') {
+        wasmFullPassI64(`(module
+            (func $run (param ${paramType}) (result ${resultType})
+                (${opcode} (local.get 0))
+            )
+        )`, expect, {}, `${paramType}.const ${op}`);
+
+        // The same, but now the input is a constant.
+        wasmFullPassI64(`(module
+            (func $run (result ${resultType})
+                (${opcode} (${paramType}.const ${op}))
+            )
+        )`, expect);
+    } else if (paramType === 'i64') {
+        wasmFullPass(`(module
+           (func $f (param ${paramType}) (result ${resultType})
+            (${opcode} (local.get 0))
+           )
+           (func (export "run") (result ${resultType})
+            i64.const ${op}
+            call $f
+           )
+        )`, expect, {});
+    } else {
+        wasmFullPass(`(module
+           (func (param ${paramType}) (result ${resultType})
+            (${opcode} (local.get 0)))
+            (export "run" (func 0))
+        )`, expect, {}, op);
+    }
+
+    for (var bad of ['i32', 'f32', 'f64', 'i64']) {
+        if (bad !== resultType) {
+            wasmFailValidateText(
+                `(module (func (param ${paramType}) (result ${bad}) (${opcode} (local.get 0))))`,
+                mismatchError(resultType, bad)
+            );
+        }
+
+        if (bad !== paramType) {
+            wasmFailValidateText(
+                `(module (func (param ${bad}) (result ${resultType}) (${opcode} (local.get 0))))`,
+                mismatchError(bad, paramType)
+            );
+        }
+    }
+}
+
+function testConversion(resultType, opcode, paramType, op, expect) {
+  testConversion0(resultType, `${resultType}.${opcode}/${paramType}`, paramType, op, expect);
+}
+
+function testSignExtension(resultType, opcode, paramType, op, expect) {
+  testConversion0(resultType, `${resultType}.${opcode}`, paramType, op, expect);
+}
+
+function testTrap(resultType, opcode, paramType, op) {
+    let func = wasmEvalText(`(module
+        (func
+            (param ${paramType})
+            (result ${resultType})
+            (${resultType}.${opcode}/${paramType} (local.get 0))
+        )
+        (func
+            (param ${paramType})
+            local.get 0
+            call 0
+            drop
+        )
+        (export "" (func 1))
+    )`).exports[""];
+
+    let expectedError = op === 'nan' ? /invalid conversion to integer/ : /integer overflow/;
+
+    assertErrorMessage(() => func(jsify(op)), Error, expectedError);
+}
+
+var p = Math.pow;
+
+testConversion('i32', 'wrap', 'i64', '0x100000028', 40);
+testConversion('i32', 'wrap', 'i64', -10, -10);
+testConversion('i32', 'wrap', 'i64', "0xffffffff7fffffff", 0x7fffffff);
+testConversion('i32', 'wrap', 'i64', "0xffffffff00000000", 0);
+testConversion('i32', 'wrap', 'i64', "0xfffffffeffffffff", -1);
+testConversion('i32', 'wrap', 'i64', "0x1234567801abcdef", 0x01abcdef);
+testConversion('i32', 'wrap', 'i64', "0x8000000000000002", 2);
+
+testConversion('i64', 'extend_s', 'i32', 0, 0);
+testConversion('i64', 'extend_s', 'i32', 1234, 1234);
+testConversion('i64', 'extend_s', 'i32', -567, -567);
+testConversion('i64', 'extend_s', 'i32', 0x7fffffff, "0x000000007fffffff");
+testConversion('i64', 'extend_s', 'i32', 0x80000000, "0xffffffff80000000");
+
+testConversion('i64', 'extend_u', 'i32', 0, 0);
+testConversion('i64', 'extend_u', 'i32', 1234, 1234);
+testConversion('i64', 'extend_u', 'i32', -567, "0x00000000fffffdc9");
+testConversion('i64', 'extend_u', 'i32', -1, "0x00000000ffffffff");
+testConversion('i64', 'extend_u', 'i32', 0x7fffffff, "0x000000007fffffff");
+testConversion('i64', 'extend_u', 'i32', 0x80000000, "0x0000000080000000");
+
+testConversion('f32', 'convert_s', 'i64', 1, 1.0);
+testConversion('f32', 'convert_s', 'i64', -1, -1.0);
+testConversion('f32', 'convert_s', 'i64', 0, 0.0);
+testConversion('f32', 'convert_s', 'i64', "0x7fffffffffffffff", 9223372036854775807.0);
+testConversion('f32', 'convert_s', 'i64', "0x8000000000000000", -9223372036854775808.0);
+testConversion('f32', 'convert_s', 'i64', "0x11db9e76a2483", 314159275180032.0);
+testConversion('f32', 'convert_s', 'i64', "0x7fffffff", 2147483648.0); // closest approx.
+testConversion('f32', 'convert_s', 'i64', "0x80000000", 2147483648.0);
+testConversion('f32', 'convert_s', 'i64', "0x80000001", 2147483648.0); // closest approx.
+
+// Interesting values at the boundaries.
+testConversion('f32', 'convert_s', 'i64', "0x358a09a000000002", 3857906751034621952);
+testConversion('f32', 'convert_s', 'i64', "0x8000004000000001", -9223371487098961920);
+testConversion('f32', 'convert_s', 'i64', "0xffdfffffdfffffff", -9007200328482816);
+testConversion('f32', 'convert_s', 'i64', "0x0020000020000001", 9007200328482816);
+testConversion('f32', 'convert_s', 'i64', "0x7fffff4000000001", 9223371487098961920);
+
+testConversion('f64', 'convert_s', 'i64', 1, 1.0);
+testConversion('f64', 'convert_s', 'i64', -1, -1.0);
+testConversion('f64', 'convert_s', 'i64', 0, 0.0);
+testConversion('f64', 'convert_s', 'i64', "0x7fffffffffffffff", 9223372036854775807.0);
+testConversion('f64', 'convert_s', 'i64', "0x8000000000000000", -9223372036854775808.0);
+testConversion('f64', 'convert_s', 'i64', "0x10969d374b968e", 4669201609102990);
+testConversion('f64', 'convert_s', 'i64', "0x7fffffff", 2147483647.0);
+testConversion('f64', 'convert_s', 'i64', "0x80000000", 2147483648.0);
+testConversion('f64', 'convert_s', 'i64', "0x80000001", 2147483649.0);
+
+testConversion('f32', 'convert_u', 'i64', 1, 1.0);
+testConversion('f32', 'convert_u', 'i64', 0, 0.0);
+testConversion('f32', 'convert_u', 'i64', "0x7fffffffffffffff", 9223372036854775807.0);
+testConversion('f32', 'convert_u', 'i64', "0x8000000000000000", 9223372036854775808.0);
+testConversion('f32', 'convert_u', 'i64', -1, 18446744073709551616.0);
+testConversion('f32', 'convert_u', 'i64', "0xffff0000ffff0000", 18446462598732840000.0);
+
+// Interesting values at the boundaries.
+testConversion('f32', 'convert_u', 'i64', "0x100404900000008", 72128280609685500);
+testConversion('f32', 'convert_u', 'i64', "0x7fffff4000000001", 9223371487098962000);
+testConversion('f32', 'convert_u', 'i64', "0x0020000020000001", 9007200328482816);
+testConversion('f32', 'convert_u', 'i64', "0x7fffffbfffffffff", 9223371487098961920);
+testConversion('f32', 'convert_u', 'i64', "0x8000008000000001", 9223373136366403584);
+testConversion('f32', 'convert_u', 'i64', "0xfffffe8000000001", 18446742974197923840);
+
+testConversion('f64', 'convert_u', 'i64', 1, 1.0);
+testConversion('f64', 'convert_u', 'i64', 0, 0.0);
+testConversion('f64', 'convert_u', 'i64', "0x7fffffffffffffff", 9223372036854775807.0);
+testConversion('f64', 'convert_u', 'i64', "0x8000000000000000", 9223372036854775808.0);
+testConversion('f64', 'convert_u', 'i64', -1, 18446744073709551616.0);
+testConversion('f64', 'convert_u', 'i64', "0xffff0000ffff0000", 18446462603027743000.0);
+testConversion('f64', 'convert_u', 'i64', "0xbf869c3369c26401", 13800889852755077000);
+testConversion('f64', 'convert_u', 'i64', "0x7fffff4000000001", 9223371212221054976);
+testConversion('f64', 'convert_u', 'i64', "0x8000008000000001", 9223372586610589696);
+testConversion('f64', 'convert_u', 'i64', "0xfffffe8000000001", 18446742424442109952);
+
+testConversion('i64', 'trunc_s', 'f64', 0.0, 0);
+testConversion('i64', 'trunc_s', 'f64', "-0.0", 0);
+testConversion('i64', 'trunc_s', 'f64', 1.0, 1);
+testConversion('i64', 'trunc_s', 'f64', 1.1, 1);
+testConversion('i64', 'trunc_s', 'f64', 1.5, 1);
+testConversion('i64', 'trunc_s', 'f64', 1.99, 1);
+testConversion('i64', 'trunc_s', 'f64', 40.1, 40);
+testConversion('i64', 'trunc_s', 'f64', -1.0, -1);
+testConversion('i64', 'trunc_s', 'f64', -1.1, -1);
+testConversion('i64', 'trunc_s', 'f64', -1.5, -1);
+testConversion('i64', 'trunc_s', 'f64', -1.99, -1);
+testConversion('i64', 'trunc_s', 'f64', -2.0, -2);
+testConversion('i64', 'trunc_s', 'f64', 4294967296.1, "0x100000000");
+testConversion('i64', 'trunc_s', 'f64', -4294967296.8, "0xffffffff00000000");
+testConversion('i64', 'trunc_s', 'f64', 9223372036854774784.8, "0x7ffffffffffffc00");
+testConversion('i64', 'trunc_s', 'f64', -9223372036854775808.3, "0x8000000000000000");
+
+testConversion('i64', 'trunc_u', 'f64', 0.0, 0);
+testConversion('i64', 'trunc_u', 'f64', "-0.0", 0);
+testConversion('i64', 'trunc_u', 'f64', 1.0, 1);
+testConversion('i64', 'trunc_u', 'f64', 1.1, 1);
+testConversion('i64', 'trunc_u', 'f64', 1.5, 1);
+testConversion('i64', 'trunc_u', 'f64', 1.99, 1);
+testConversion('i64', 'trunc_u', 'f64', -0.9, 0);
+testConversion('i64', 'trunc_u', 'f64', 40.1, 40);
+testConversion('i64', 'trunc_u', 'f64', 4294967295, "0xffffffff");
+testConversion('i64', 'trunc_u', 'f64', 4294967296.1, "0x100000000");
+testConversion('i64', 'trunc_u', 'f64', 1e8, "0x5f5e100");
+testConversion('i64', 'trunc_u', 'f64', 1e16, "0x2386f26fc10000");
+testConversion('i64', 'trunc_u', 'f64', 9223372036854775808, "0x8000000000000000");
+testConversion('i64', 'trunc_u', 'f64', 18446744073709549568.1, -2048);
+
+testConversion('i64', 'trunc_s', 'f32', 0.0, 0);
+testConversion('i64', 'trunc_s', 'f32', "-0.0", 0);
+testConversion('i64', 'trunc_s', 'f32', 1.0, 1);
+testConversion('i64', 'trunc_s', 'f32', 1.1, 1);
+testConversion('i64', 'trunc_s', 'f32', 1.5, 1);
+testConversion('i64', 'trunc_s', 'f32', 1.99, 1);
+testConversion('i64', 'trunc_s', 'f32', 40.1, 40);
+testConversion('i64', 'trunc_s', 'f32', -1.0, -1);
+testConversion('i64', 'trunc_s', 'f32', -1.1, -1);
+testConversion('i64', 'trunc_s', 'f32', -1.5, -1);
+testConversion('i64', 'trunc_s', 'f32', -1.99, -1);
+testConversion('i64', 'trunc_s', 'f32', -2.0, -2);
+testConversion('i64', 'trunc_s', 'f32', 4294967296.1, "0x100000000");
+testConversion('i64', 'trunc_s', 'f32', -4294967296.8, "0xffffffff00000000");
+testConversion('i64', 'trunc_s', 'f32', 9223371487098961920.0, "0x7fffff8000000000");
+testConversion('i64', 'trunc_s', 'f32', -9223372036854775808.3, "0x8000000000000000");
+
+testConversion('i64', 'trunc_u', 'f32', 0.0, 0);
+testConversion('i64', 'trunc_u', 'f32', "-0.0", 0);
+testConversion('i64', 'trunc_u', 'f32', 1.0, 1);
+testConversion('i64', 'trunc_u', 'f32', 1.1, 1);
+testConversion('i64', 'trunc_u', 'f32', 1.5, 1);
+testConversion('i64', 'trunc_u', 'f32', 1.99, 1);
+testConversion('i64', 'trunc_u', 'f32', -0.9, 0);
+testConversion('i64', 'trunc_u', 'f32', 40.1, 40);
+testConversion('i64', 'trunc_u', 'f32', 1e8, "0x5f5e100");
+testConversion('i64', 'trunc_u', 'f32', 4294967296, "0x100000000");
+testConversion('i64', 'trunc_u', 'f32', 18446742974197923840.0, "0xffffff0000000000");
+
+testTrap('i64', 'trunc_s', 'f64', 9223372036854776000.0);
+testTrap('i64', 'trunc_s', 'f64', -9223372036854778000.0);
+testTrap('i64', 'trunc_s', 'f64', "nan");
+testTrap('i64', 'trunc_s', 'f64', "inf");
+testTrap('i64', 'trunc_s', 'f64', "-inf");
+
+testTrap('i64', 'trunc_u', 'f64', -1);
+testTrap('i64', 'trunc_u', 'f64', 18446744073709551616.0);
+testTrap('i64', 'trunc_u', 'f64', "nan");
+testTrap('i64', 'trunc_u', 'f64', "inf");
+testTrap('i64', 'trunc_u', 'f64', "-inf");
+
+testTrap('i64', 'trunc_s', 'f32', 9223372036854776000.0);
+testTrap('i64', 'trunc_s', 'f32', -9223372586610630000.0);
+testTrap('i64', 'trunc_s', 'f32', "nan");
+testTrap('i64', 'trunc_s', 'f32', "inf");
+testTrap('i64', 'trunc_s', 'f32', "-inf");
+
+testTrap('i64', 'trunc_u', 'f32', 18446744073709551616.0);
+testTrap('i64', 'trunc_u', 'f32', -1);
+testTrap('i64', 'trunc_u', 'f32', "nan");
+testTrap('i64', 'trunc_u', 'f32', "inf");
+testTrap('i64', 'trunc_u', 'f32', "-inf");
+
+testConversion('i64', 'reinterpret', 'f64', 40.09999999999968, "0x40440ccccccccca0");
+testConversion('f64', 'reinterpret', 'i64', "0x40440ccccccccca0", 40.09999999999968);
+
+var u64max = '0xffffffffffffffff';
+var s64max = '0x7fffffffffffffff';
+var s64min = '-0x8000000000000000';
+var s32max = 2147483647;
+var s32min = -2147483648;
+
+testConversion('i32', 'trunc_s:sat', 'f32', NaN, 0);
+testConversion('i32', 'trunc_s:sat', 'f32', Infinity, s32max);
+testConversion('i32', 'trunc_s:sat', 'f32', -Infinity, s32min);
+testConversion('i32', 'trunc_s:sat', 'f32', p(2, 31), s32max);
+testConversion('i32', 'trunc_s:sat', 'f32', -p(2, 31) - 256, s32min);
+
+testConversion('i32', 'trunc_s:sat', 'f64', NaN, 0);
+testConversion('i32', 'trunc_s:sat', 'f64', Infinity, s32max);
+testConversion('i32', 'trunc_s:sat', 'f64', -Infinity, s32min);
+testConversion('i32', 'trunc_s:sat', 'f64', p(2, 31), s32max);
+testConversion('i32', 'trunc_s:sat', 'f64', -p(2, 31) - 1, s32min);
+
+testConversion('i32', 'trunc_u:sat', 'f32', NaN, 0);
+testConversion('i32', 'trunc_u:sat', 'f32', Infinity, -1);
+testConversion('i32', 'trunc_u:sat', 'f32', -Infinity, 0);
+testConversion('i32', 'trunc_u:sat', 'f32', -1, 0);
+testConversion('i32', 'trunc_u:sat', 'f32', p(2, 32), -1);
+
+testConversion('i32', 'trunc_u:sat', 'f64', NaN, 0);
+testConversion('i32', 'trunc_u:sat', 'f64', Infinity, -1);
+testConversion('i32', 'trunc_u:sat', 'f64', -Infinity, 0);
+testConversion('i32', 'trunc_u:sat', 'f64', -1, 0);
+testConversion('i32', 'trunc_u:sat', 'f64', p(2, 32), -1);
+
+testConversion('i64', 'trunc_s:sat', 'f64', 9223372036854776000.0, s64max);
+testConversion('i64', 'trunc_s:sat', 'f64', -9223372036854778000.0, s64min);
+testConversion('i64', 'trunc_s:sat', 'f64', 'nan', '0');
+testConversion('i64', 'trunc_s:sat', 'f64', 'inf', s64max);
+testConversion('i64', 'trunc_s:sat', 'f64', '-inf', s64min);
+
+testConversion('i64', 'trunc_u:sat', 'f64', -1, '0');
+testConversion('i64', 'trunc_u:sat', 'f64', 18446744073709551616.0, u64max);
+testConversion('i64', 'trunc_u:sat', 'f64', 'nan', '0');
+testConversion('i64', 'trunc_u:sat', 'f64', 'inf', u64max);
+testConversion('i64', 'trunc_u:sat', 'f64', '-inf', '0');
+
+testConversion('i64', 'trunc_s:sat', 'f32', 9223372036854776000.0, s64max);
+testConversion('i64', 'trunc_s:sat', 'f32', -9223372586610630000.0, s64min);
+testConversion('i64', 'trunc_s:sat', 'f32', 'nan', '0');
+testConversion('i64', 'trunc_s:sat', 'f32', 'inf', s64max);
+testConversion('i64', 'trunc_s:sat', 'f32', '-inf', s64min);
+
+testConversion('i64', 'trunc_u:sat', 'f32', 18446744073709551616.0, u64max);
+testConversion('i64', 'trunc_u:sat', 'f32', -1, '0');
+testConversion('i64', 'trunc_u:sat', 'f32', 'nan', '0');
+testConversion('i64', 'trunc_u:sat', 'f32', 'inf', u64max);
+testConversion('i64', 'trunc_u:sat', 'f32', '-inf', '0');
+
+testSignExtension('i32', 'extend8_s', 'i32', 0x7F, 0x7F);
+testSignExtension('i32', 'extend8_s', 'i32', 0x80, -0x80);
+testSignExtension('i32', 'extend16_s', 'i32', 0x7FFF, 0x7FFF);
+testSignExtension('i32', 'extend16_s', 'i32', 0x8000, -0x8000);
+testSignExtension('i64', 'extend8_s', 'i64', 0x7F, 0x7F);
+testSignExtension('i64', 'extend8_s', 'i64', 0x80, -0x80);
+testSignExtension('i64', 'extend16_s', 'i64', 0x7FFF, 0x7FFF);
+testSignExtension('i64', 'extend16_s', 'i64', 0x8000, -0x8000);
+testSignExtension('i64', 'extend32_s', 'i64', 0x7FFFFFFF, 0x7FFFFFFF);
+testSignExtension('i64', 'extend32_s', 'i64', "0x80000000", "0xFFFFFFFF80000000");
+
+// i32.trunc_s* : all values in ] -2**31 - 1; 2**31 [ are acceptable.
+// f32:
+testConversion('i32', 'trunc_s', 'f32', 40.1, 40);
+testConversion('i32', 'trunc_s', 'f32', p(2, 31) - 128, p(2, 31) - 128); // last f32 value exactly representable < 2**31.
+testConversion('i32', 'trunc_s', 'f32', -p(2, 31), -p(2,31)); // last f32 value exactly representable > -2**31 - 1.
+
+testTrap('i32', 'trunc_s', 'f32', 'nan');
+testTrap('i32', 'trunc_s', 'f32', 'inf');
+testTrap('i32', 'trunc_s', 'f32', '-inf');
+testTrap('i32', 'trunc_s', 'f32', p(2, 31));
+testTrap('i32', 'trunc_s', 'f32', -p(2,31) - 256);
+
+testConversion('i32', 'trunc_s', 'f64', 40.1, 40);
+testConversion('i32', 'trunc_s', 'f64', p(2,31) - 0.001, p(2,31) - 1); // example value near the top.
+testConversion('i32', 'trunc_s', 'f64', -p(2,31) - 0.999, -p(2,31)); // example value near the bottom.
+
+// f64:
+testTrap('i32', 'trunc_s', 'f64', 'nan');
+testTrap('i32', 'trunc_s', 'f64', 'inf');
+testTrap('i32', 'trunc_s', 'f64', '-inf');
+testTrap('i32', 'trunc_s', 'f64', p(2,31));
+testTrap('i32', 'trunc_s', 'f64', -p(2,31) - 1);
+
+// i32.trunc_u* : all values in ] -1; 2**32 [ are acceptable.
+// f32:
+testConversion('i32', 'trunc_u', 'f32', 40.1, 40);
+testConversion('i32', 'trunc_u', 'f32', p(2,31), p(2,31)|0);
+testConversion('i32', 'trunc_u', 'f32', p(2,32) - 256, (p(2,32) - 256)|0); // last f32 value exactly representable < 2**32.
+testConversion('i32', 'trunc_u', 'f32', -0.99, 0); // example value near the bottom.
+
+testTrap('i32', 'trunc_u', 'f32', 'nan');
+testTrap('i32', 'trunc_u', 'f32', 'inf');
+testTrap('i32', 'trunc_u', 'f32', '-inf');
+testTrap('i32', 'trunc_u', 'f32', -1);
+testTrap('i32', 'trunc_u', 'f32', p(2,32));
+
+// f64:
+testConversion('i32', 'trunc_u', 'f64', 40.1, 40);
+testConversion('i32', 'trunc_u', 'f64', p(2,32) - 0.001, (p(2,32) - 1)|0); // example value near the top.
+testConversion('i32', 'trunc_u', 'f64', -0.99999, 0); // example value near the bottom.
+
+testTrap('i32', 'trunc_u', 'f64', 'nan');
+testTrap('i32', 'trunc_u', 'f64', 'inf');
+testTrap('i32', 'trunc_u', 'f64', '-inf');
+testTrap('i32', 'trunc_u', 'f64', -1);
+testTrap('i32', 'trunc_u', 'f64', p(2,32));
+
+// Other opcodes.
+testConversion('i32', 'reinterpret', 'f32', 40.1, 1109419622);
+testConversion('f32', 'reinterpret', 'i32', 40, 5.605193857299268e-44);
+
+testConversion('f32', 'convert_s', 'i32', 40, 40);
+testConversion('f32', 'convert_u', 'i32', 40, 40);
+
+testConversion('f64', 'convert_s', 'i32', 40, 40);
+testConversion('f64', 'convert_u', 'i32', 40, 40);
+
+testConversion('f32', 'demote', 'f64', 40.1, 40.099998474121094);
+testConversion('f64', 'promote', 'f32', 40.1, 40.099998474121094);
+
+// Non-canonical NaNs.
+
+// Wasm v1.1 spec 4.3.4 "Conversions", subsection demote(z): if z is a NaN but
+// not canonical, return any NaN.  That is, the sign is arbitrary and the
+// payload is arbitrary, except that the most significant bit of the payload
+// must be set.  We check simply that a quiet NaN is returned and ignore the
+// sign and payload.
+
+wasmFullPass(`
+(module
+ (func (result i32)
+  (i32.and
+    (i32.const 0x7FC00000)
+    (i32.reinterpret/f32
+      (f32.demote/f64 (f64.const -nan:0x4444444444444)))))
+ (export "run" (func 0)))`,
+             0x7FC00000);
+
+// Wasm v1.1 spec 4.3.4 "Conversions", subsection promote(z): if z is a NaN but
+// not canonical, return any NaN.  See above.
+
+wasmFullPass(`
+(module
+ (func (result i64)
+   (i64.and
+     (i64.const 0x7FF8000000000000)
+     (i64.reinterpret/f64 (f64.promote/f32 (f32.const -nan:0x222222)))))
+ (export "run" (func 0)))`,
+             0x7FF8_0000_0000_0000n);
diff --git a/js/src/jit-test/tests/wasm/cross-global.js b/js/src/jit-test/tests/wasm/cross-global.js
new file mode 100644
index 0000000000..07b705d540
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/cross-global.js
@@ -0,0 +1,10 @@
+const Module = WebAssembly.Module;
+
+// Create cross-compartment wrappers to typed arrays and array buffers.
+var g = newGlobal();
+var code1 = g.eval("wasmTextToBinary('(module)')");
+var code2 = g.eval("wasmTextToBinary('(module)').buffer");
+
+// Should get unwrapped.
+assertEq(new Module(code1) instanceof Module, true);
+assertEq(new Module(code2) instanceof Module, true);
diff --git a/js/src/jit-test/tests/wasm/custom-section.js b/js/src/jit-test/tests/wasm/custom-section.js
new file mode 100644
index 0000000000..e0a9946242
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/custom-section.js
@@ -0,0 +1,48 @@
+function arraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < b.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function testCustomSection(moduleText, customSectionName, expectedBytes) {
+  let module = new WebAssembly.Module(wasmTextToBinary(moduleText));
+
+  let sections = WebAssembly.Module.customSections(module, customSectionName);
+  assertEq(sections.length, 1);
+
+  let section = sections[0];
+  let sectionView = new Uint8Array(section);
+
+  if (!arraysEqual(sectionView, expectedBytes)) {
+    let got = JSON.stringify(Array.from(sectionView));
+    let expected = JSON.stringify(Array.from(expectedBytes));
+    assertEq(true, false, `got: ${got}, expected: ${expected}`)
+  }
+}
+
+// Test an unknown custom section
+testCustomSection(
+  `(module (@custom "unknown" "\\00\\01\\02\\03\\04"))`,
+  "unknown",
+  [0, 1, 2, 3, 4]);
+
+// Test the name section
+testCustomSection(
+  `(module (func $test))`,
+  "name",
+  [
+    /* subsection is functions */ 1,
+    /* subsection is 7 bytes */ 7,
+    /* name map has 1 entry */ 1,
+    /* first entry is index */ 0,
+    /* first entry string 4 bytes */ 4,
+    /* 't' */ 116,
+    /* 'e' */ 101,
+    /* 's' */ 115,
+    /* 't' */ 116]);
diff --git a/js/src/jit-test/tests/wasm/declared-segs.js b/js/src/jit-test/tests/wasm/declared-segs.js
new file mode 100644
index 0000000000..d0f3a175ef
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/declared-segs.js
@@ -0,0 +1,58 @@
+// Declared segments parse and validate
+wasmFullPass(`
+	(module
+		(func $f1)
+		(elem declare $f1)
+		(elem declare funcref (ref.null func))
+		(func $run)
+		(export "run" (func $run))
+	)
+`);
+
+// Declared segments can be used with externref
+wasmFullPass(`
+	(module
+		(elem declare externref (ref.null extern))
+		(func $run)
+		(export "run" (func $run))
+	)
+`);
+
+// Declared segments cannot be used at runtime
+{
+	let inst = wasmEvalText(`
+		(module
+			(func $f1)
+			(table 1 1 funcref)
+			(elem $e1 declare $f1)
+			(func (export "testfn") (table.init $e1 (i32.const 0) (i32.const 0) (i32.const 1)))
+		)
+	`);
+	assertErrorMessage(() => inst.exports.testfn(), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Declared segments can be dropped, although this has no effect
+wasmEvalText(`
+	(module
+		(func $f1)
+		(table 1 1 funcref)
+		(elem $e1 declare $f1)
+		(func $start (elem.drop $e1) (elem.drop $e1))
+		(start $start)
+	)
+`)
+
+// Declared segments don't cause initialization of a table
+wasmAssert(`
+	(module
+		(func $f1)
+		(table 1 1 funcref)
+		(elem declare $f1)
+		(func $at (param i32) (result i32)
+			local.get 0
+			table.get 0
+			ref.is_null
+		)
+		(export "at" (func $at))
+	)
+`, [{type: 'i32', func: '$at', args: ['i32.const 0'], expected: '1'}]);
diff --git a/js/src/jit-test/tests/wasm/directiveless/README.md b/js/src/jit-test/tests/wasm/directiveless/README.md
new file mode 100644
index 0000000000..9687e7a9b6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/directiveless/README.md
@@ -0,0 +1 @@
+DO NOT ADD A directives.txt FILE IN THIS DIRECTORY.  THE TEST CASE MUST RUN WITH MINIMAL PRELIMINARIES.
diff --git a/js/src/jit-test/tests/wasm/directiveless/bug1645310.js b/js/src/jit-test/tests/wasm/directiveless/bug1645310.js
new file mode 100644
index 0000000000..3532886c6a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/directiveless/bug1645310.js
@@ -0,0 +1,61 @@
+// |jit-test| --wasm-compiler=optimizing; skip-if: !wasmIsSupported()
+
+// In this case we're setting things up so that wasm can't be compiled, as the
+// only available compiler is Ion, and enabling the Debugger will disable Ion.
+//
+// The test tests that the lazy creation of the WebAssembly object is not
+// dependent on whether WebAssembly can be compiled or not: if wasm is supported
+// then the WebAssembly object should always be created.  The fact that wasm
+// can't be compiled is a separate matter.
+//
+// IT'S IMPORTANT NOT TO MENTION THE WEBASSEMBLY OBJECT UNTIL AFTER THE DEBUGGER
+// HAS BEEN CREATED, AND NOT TO LOAD lib/wasm.js OR OTHER WASM CODE HERE.
+
+var g7 = newGlobal({newCompartment: true});
+g7.parent = this;
+g7.eval("var dbg = Debugger(parent)");
+assertEq(typeof WebAssembly, "object");
+
+// Test that validation works even if compilers are not available.
+
+WebAssembly.validate(wasmTextToBinary('(module (func))'));
+
+// Test that compilation fails with a sensible error.
+
+var bits = wasmTextToBinary('(module (func))');
+var msg = /no WebAssembly compiler available/
+var exn;
+
+exn = null;
+try { new WebAssembly.Module(bits); } catch (e) { exn = e; }
+assertEq(Boolean(exn), true);
+assertEq(Boolean(String(exn).match(msg)), true);
+
+exn = null;
+try { WebAssembly.compile(bits); } catch (e) { exn = e; }
+assertEq(Boolean(exn), true);
+assertEq(Boolean(String(exn).match(msg)), true);
+
+exn = null;
+try { WebAssembly.instantiate(bits); } catch (e) { exn = e; }
+assertEq(Boolean(exn), true);
+assertEq(Boolean(String(exn).match(msg)), true);
+
+// We do not use wasmStreamingEnabled() here because that checks whether
+// compilers are available, and that is precisely what we want to be checking
+// ourselves.  But streaming compilation is available only if there are helper
+// threads, so that's an OK proxy.
+
+if (helperThreadCount() > 0) {
+    exn = null;
+    WebAssembly.compileStreaming(bits).catch(e => { exn = e; });
+    drainJobQueue();
+    assertEq(Boolean(exn), true);
+    assertEq(Boolean(String(exn).match(msg)), true);
+
+    exn = null;
+    WebAssembly.instantiateStreaming(bits).catch(e => { exn = e; });
+    drainJobQueue();
+    assertEq(Boolean(exn), true);
+    assertEq(Boolean(String(exn).match(msg)), true);
+}
diff --git a/js/src/jit-test/tests/wasm/directiveless/bug1664979.js b/js/src/jit-test/tests/wasm/directiveless/bug1664979.js
new file mode 100644
index 0000000000..e6b8bd7c3c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/directiveless/bug1664979.js
@@ -0,0 +1,21 @@
+// |jit-test| --fuzzing-safe; --ion-offthread-compile=off; skip-if: !wasmIsSupported()
+
+var all = [undefined, null, ];
+function AsmModule(stdlib) {
+    "use asm";
+    var fround = stdlib.Math.fround;
+    function fltConvNot(y38) {
+        y38 = fround(y38);
+        var i38 = 0;
+        i38 = ~((~~y38) | 0);
+        return (!!i38) | 0;
+    }
+    return {
+        fltConvNot: fltConvNot,
+    };
+}
+var asmModule = AsmModule({
+    Math: Math
+});
+for (var i38 = 0; i38 < 10; ++i38)
+  asmModule.fltConvNot(all[i38])
diff --git a/js/src/jit-test/tests/wasm/directiveless/bug1666051.js b/js/src/jit-test/tests/wasm/directiveless/bug1666051.js
new file mode 100644
index 0000000000..6b94ef921e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/directiveless/bug1666051.js
@@ -0,0 +1,12 @@
+// |jit-test| --fuzzing-safe; --no-threads; --no-baseline; --no-ion; skip-if: !wasmIsSupported()
+
+(function (stdlib) {
+  "use asm";
+  var sqrt = stdlib.Math.sqrt;
+  function f(i0) {
+    i0 = i0 | 0;
+    i0 = ~~sqrt(-.5);
+    return (1 / (1 >> (.0 == .0)) & i0 >> 1);
+  }
+  return f;
+})(this)();
diff --git a/js/src/jit-test/tests/wasm/directives.txt b/js/src/jit-test/tests/wasm/directives.txt
new file mode 100644
index 0000000000..1853ee0fe8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); test-also=--wasm-test-serialization; test-also=--wasm-compiler=optimizing --no-avx; skip-variant-if: --wasm-compiler=optimizing --no-avx, !getBuildConfiguration().x86 && !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/disasm.js b/js/src/jit-test/tests/wasm/disasm.js
new file mode 100644
index 0000000000..9e9a3f2116
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/disasm.js
@@ -0,0 +1,43 @@
+// |jit-test| skip-if: !hasDisassembler()
+
+// Test that the disassembler is reasonably sane.
+
+var mod = new WebAssembly.Module(wasmTextToBinary(`
+(module
+   (func $hum (import "m" "hum") (param i32) (result f64))
+   (memory 1)
+   (func $hi (export "f") (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)
+     (i32.add (i32.load (local.get 5)) (i32.load (local.get 6))))
+   (func $ho (param i32) (result i32) (i32.const 37))
+)
+`));
+
+// The following capture the disassembly as a string.  We can't really check
+// that no other output is produced.
+
+var s = wasmDis(mod, {tier:'best', asString:true});
+assertEq(typeof s, "string")
+assertEq(s.match(/Kind = Function/g).length, 3)
+
+var ins = new WebAssembly.Instance(mod, {m:{hum:(x) => x+0.5}});
+var s = wasmDis(ins, {tier:'best', asString:true});
+assertEq(typeof s, "string")
+assertEq(s.match(/Kind = Function/g).length, 3)
+
+var s = wasmDis(ins.exports.f, {tier:'best', asString:true})
+assertEq(typeof s, "string")
+
+var s = wasmDis(ins, {asString:true, kinds:"InterpEntry,ImportInterpExit,Function"})
+assertEq(typeof s, "string")
+assertEq(s.match(/Kind = Function/g).length, 3)
+assertEq(s.match(/Kind = InterpEntry/g).length, 1)
+assertEq(s.match(/Kind = ImportInterpExit/g).length, 1)
+assertEq(s.match(/name = hi/g).length, 2)
+assertEq(s.match(/name = ho/g).length, 1)
+assertEq(s.match(/name = hum/g).length, 2)
+
+// This one prints to stderr, we can't check the output but we can check that a
+// string is not returned.
+
+var s = wasmDis(ins, {tier:'best'})
+assertEq(typeof s, "undefined")
diff --git a/js/src/jit-test/tests/wasm/drop.js b/js/src/jit-test/tests/wasm/drop.js
new file mode 100644
index 0000000000..3a2bda66e5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/drop.js
@@ -0,0 +1,45 @@
+for (let type of ['i32', 'f32', 'f64']) {
+    assertEq(wasmEvalText(`
+        (module
+         (func $test (param $p ${type}) (param $p2 ${type}) (result ${type})
+            local.get $p
+            local.get $p2
+            (block)
+            drop
+         )
+         (export "test" (func $test))
+        )
+    `).exports.test(0x1337abc0, 0xffffffff), 0x1337abc0);
+}
+
+assertEq(wasmEvalText(`
+    (module
+     (func $test (param $p i32) (param $p2 f32) (param $p3 f64) (param $p4 i32) (result i32)
+        local.get $p
+        local.get $p2
+        local.get $p3
+        local.get $p4
+        (block)
+        drop
+        (block)
+        (block)
+        drop
+        drop
+     )
+     (export "test" (func $test))
+    )
+`).exports.test(0x1337abc0, 0xffffffff), 0x1337abc0);
+
+wasmAssert(`
+    (module
+     (func $test (param $p i64) (param $p2 i64) (result i64)
+        local.get $p
+        local.get $p2
+        (block)
+        drop
+     )
+     (export "test" (func $test))
+    )
+`, [
+    { type: 'i64', func: '$test', args: ['(i64.const 0x1337abc0)', '(i64.const -1)'], expected: '0x1337abc0' }
+]);
diff --git a/js/src/jit-test/tests/wasm/errors.js b/js/src/jit-test/tests/wasm/errors.js
new file mode 100644
index 0000000000..771621e363
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/errors.js
@@ -0,0 +1,180 @@
+load(libdir + "wasm-binary.js");
+
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const CompileError = WebAssembly.CompileError;
+const RuntimeError = WebAssembly.RuntimeError;
+
+function getWasmFunctionIndex(line) {
+    return Number(line.match(/^wasm-function\[(\d*)\]$/)[1]);
+}
+
+function getWasmBytecode(column) {
+    return parseInt(column.match(/^0x([0-9a-f]*)$/)[1], 16);
+}
+
+function parseStack(stack) {
+    var frames = stack.split('\n');
+    assertEq(frames[frames.length-1], "");
+    frames.length--;
+    return frames.map(frame => {
+        var res = frame.match(/^(.*)@(.*):(.*):(.*)$/);
+        assertEq(res !== null, true);
+        return {name: res[1], url: res[2], line: res[3], column: res[4]};
+    });
+}
+
+function testExn(opcode, binary, type, msg, exn) {
+    assertEq(exn instanceof type, true);
+    assertEq(msg.test(exn.message), true);
+
+    var stack = parseStack(exn.stack);
+    assertEq(stack.length > 1, true);
+    var innermost = stack[0];
+    var funcIndex = getWasmFunctionIndex(innermost.line);
+    var bytecode = getWasmBytecode(innermost.column);
+    assertEq(exn.lineNumber, bytecode);
+    assertEq(exn.columnNumber, 1);
+    assertEq(binary[bytecode], opcode);
+
+    return {stack, binary};
+}
+
+function test(opcode, text, type, msg) {
+    var binary = new Uint8Array(wasmTextToBinary(text));
+    var exn;
+    try {
+        new Instance(new Module(binary));
+    } catch (e) {
+        exn = e;
+    }
+
+    return testExn(opcode, binary, type, msg, exn);
+}
+
+function testAccess(opcode, text, width, type, msg) {
+    var binary = new Uint8Array(wasmTextToBinary(text));
+    var instance = new Instance(new Module(binary));
+    for (var base of [64 * 1024, 2 * 64 * 1024, Math.pow(2, 30), Math.pow(2, 31), Math.pow(2, 32) - 1]) {
+        for (var sub = 0; sub < width; sub++) {
+            var ptr = base - sub;
+            let exn = null;
+            try {
+                instance.exports[''](ptr);
+            } catch (e) {
+                exn = e;
+            }
+            testExn(opcode, binary, type, msg, exn);
+        }
+    }
+}
+
+function testLoad(opcode, optext, width, type, msg) {
+    var text = `(module (memory 1) (func (export "") (param i32) (drop (${optext} (local.get 0)))))`;
+    testAccess(opcode, text, width, type, msg);
+}
+
+function testStore(opcode, optext, consttext, width, type, msg) {
+    var text = `(module (memory 1) (func (export "") (param i32) (${optext} (local.get 0) (${consttext}.const 0))))`;
+    testAccess(opcode, text, width, type, msg);
+}
+
+test(UnreachableCode, '(module (func unreachable) (start 0))', RuntimeError, /unreachable executed/);
+test(I32DivSCode, '(module (func (drop (i32.div_s (i32.const 1) (i32.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I32DivSCode, '(module (func (drop (i32.div_s (i32.const -2147483648) (i32.const -1)))) (start 0))', RuntimeError, /integer overflow/);
+test(I32DivUCode, '(module (func (drop (i32.div_u (i32.const 1) (i32.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I32RemSCode, '(module (func (drop (i32.rem_s (i32.const 1) (i32.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I32RemUCode, '(module (func (drop (i32.rem_u (i32.const 1) (i32.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I64DivSCode, '(module (func (drop (i64.div_s (i64.const 1) (i64.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I64DivSCode, '(module (func (drop (i64.div_s (i64.const -9223372036854775808) (i64.const -1)))) (start 0))', RuntimeError, /integer overflow/);
+test(I64DivUCode, '(module (func (drop (i64.div_u (i64.const 1) (i64.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I64RemSCode, '(module (func (drop (i64.rem_s (i64.const 1) (i64.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I64RemUCode, '(module (func (drop (i64.rem_u (i64.const 1) (i64.const 0)))) (start 0))', RuntimeError, /integer divide by zero/);
+test(I32TruncSF32Code, '(module (func (drop (i32.trunc_s/f32 (f32.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I32TruncSF64Code, '(module (func (drop (i32.trunc_s/f64 (f64.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I32TruncUF32Code, '(module (func (drop (i32.trunc_u/f32 (f32.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I32TruncUF64Code, '(module (func (drop (i32.trunc_u/f64 (f64.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I64TruncSF32Code, '(module (func (drop (i64.trunc_s/f32 (f32.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I64TruncSF64Code, '(module (func (drop (i64.trunc_s/f64 (f64.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I64TruncUF32Code, '(module (func (drop (i64.trunc_u/f32 (f32.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I64TruncUF64Code, '(module (func (drop (i64.trunc_u/f64 (f64.const 1e30)))) (start 0))', RuntimeError, /integer overflow/);
+test(I32TruncSF32Code, '(module (func (drop (i32.trunc_s/f32 (f32.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I32TruncSF64Code, '(module (func (drop (i32.trunc_s/f64 (f64.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I32TruncUF32Code, '(module (func (drop (i32.trunc_u/f32 (f32.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I32TruncUF64Code, '(module (func (drop (i32.trunc_u/f64 (f64.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I64TruncSF32Code, '(module (func (drop (i64.trunc_s/f32 (f32.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I64TruncSF64Code, '(module (func (drop (i64.trunc_s/f64 (f64.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I64TruncUF32Code, '(module (func (drop (i64.trunc_u/f32 (f32.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(I64TruncUF64Code, '(module (func (drop (i64.trunc_u/f64 (f64.const nan)))) (start 0))', RuntimeError, /invalid conversion to integer/);
+test(CallIndirectCode, '(module (table 1 funcref) (func (call_indirect (type 0) (i32.const 0))) (start 0))', RuntimeError, /indirect call to null/);
+test(CallIndirectCode, '(module (table 1 funcref) (func (call_indirect (type 0) (i32.const 1))) (start 0))', RuntimeError, /index out of bounds/);
+test(CallIndirectCode, '(module (table funcref (elem $blah)) (func (call_indirect (type 0) (i32.const 0))) (func $blah (param i32)) (start 0))', RuntimeError, /indirect call signature mismatch/);
+testLoad(I32Load8S, 'i32.load8_s', 1, RuntimeError, /index out of bounds/);
+testLoad(I32Load8U, 'i32.load8_u', 1, RuntimeError, /index out of bounds/);
+testLoad(I32Load16S, 'i32.load16_s', 2, RuntimeError, /index out of bounds/);
+testLoad(I32Load16U, 'i32.load16_u', 2, RuntimeError, /index out of bounds/);
+testLoad(I64Load8S, 'i64.load8_s', 1, RuntimeError, /index out of bounds/);
+testLoad(I64Load8U, 'i64.load8_u', 1, RuntimeError, /index out of bounds/);
+testLoad(I64Load16S, 'i64.load16_s', 2, RuntimeError, /index out of bounds/);
+testLoad(I64Load16U, 'i64.load16_u', 2, RuntimeError, /index out of bounds/);
+testLoad(I64Load32S, 'i64.load32_s', 4, RuntimeError, /index out of bounds/);
+testLoad(I64Load32U, 'i64.load32_u', 4, RuntimeError, /index out of bounds/);
+testLoad(I32Load, 'i32.load', 4, RuntimeError, /index out of bounds/);
+testLoad(I64Load, 'i64.load', 8, RuntimeError, /index out of bounds/);
+testLoad(F32Load, 'f32.load', 4, RuntimeError, /index out of bounds/);
+testLoad(F64Load, 'f64.load', 8, RuntimeError, /index out of bounds/);
+testStore(I32Store8, 'i32.store8', 'i32', 1, RuntimeError, /index out of bounds/);
+testStore(I32Store16, 'i32.store16', 'i32', 2, RuntimeError, /index out of bounds/);
+testStore(I64Store8, 'i64.store8', 'i64', 1, RuntimeError, /index out of bounds/);
+testStore(I64Store16, 'i64.store16', 'i64', 2, RuntimeError, /index out of bounds/);
+testStore(I64Store32, 'i64.store32', 'i64', 4, RuntimeError, /index out of bounds/);
+testStore(I32Store, 'i32.store', 'i32', 4, RuntimeError, /index out of bounds/);
+testStore(I64Store, 'i64.store', 'i64', 8, RuntimeError, /index out of bounds/);
+testStore(F32Store, 'f32.store', 'f32', 4, RuntimeError, /index out of bounds/);
+testStore(F64Store, 'f64.store', 'f64', 8, RuntimeError, /index out of bounds/);
+
+// Stack overflow isn't really a trap or part of the formally-specified
+// semantics of call so use the same InternalError as JS and use the bytecode
+// offset of the function body (which happens to start with the number of
+// local entries).
+test(4 /* = num locals */, '(module (func (local i32 i64 f32 f64) (call 0)) (start 0))', InternalError, /too much recursion/);
+
+// Test whole callstack.
+var {stack, binary} = test(UnreachableCode, `(module
+    (type $v2v (func))
+    (func $a unreachable)
+    (func $b call $a)
+    (func $c call $b)
+    (table funcref (elem $c))
+    (func $d (call_indirect (type $v2v) (i32.const 0)))
+    (func $e call $d)
+    (start $e)
+)`, RuntimeError, /unreachable executed/);
+const N = 5;
+assertEq(stack.length > N, true);
+assertEq(getWasmFunctionIndex(stack[0].line), 0);
+var lastLine = stack[0].line;
+for (var i = 1; i < N; i++) {
+    assertEq(getWasmFunctionIndex(stack[i].line), i);
+    assertEq(stack[i].line > lastLine, true);
+    lastLine = stack[i].line;
+    assertEq(binary[getWasmBytecode(stack[i].column)], i == 3 ? CallIndirectCode : CallCode);
+}
+
+function testCompileError(opcode, text) {
+    var binary = new Uint8Array(wasmTextToBinary(text));
+    var exn;
+    try {
+        new Instance(new Module(binary));
+    } catch (e) {
+        exn = e;
+    }
+
+    assertEq(exn instanceof CompileError, true);
+    var offset = Number(exn.message.match(/at offset (\d*)/)[1]);
+    assertEq(binary[offset], opcode);
+}
+
+testCompileError(CallCode, '(module (func $f (param i32)) (func $g call $f))');
+testCompileError(I32AddCode, '(module (func (i32.add (i32.const 1) (f32.const 1))))');
+testCompileError(EndCode, '(module (func (block (result i32))))');
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1744663-extended.js b/js/src/jit-test/tests/wasm/exceptions/bug-1744663-extended.js
new file mode 100644
index 0000000000..6efd8f0bb1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1744663-extended.js
@@ -0,0 +1,224 @@
+load(libdir + "eqArrayHelper.js");
+
+// These tests ensure that the gc related errors in bug 1744663 are resolved.
+
+{
+  let catchlessTry = `
+           (try
+             (do (call $gc)
+                 (throw $exn)))`;
+  let rethrow0 = `
+           (try
+             (do (call $gc)
+                 (throw $exn))
+             (catch $exn (rethrow 0)))`;
+  let rethrow1 = `
+           (try
+             (do (throw $exn))
+             (catch_all
+               (try
+                 (do (throw $exn))
+                 (catch $exn (rethrow 1)))))`;
+  let delegate0 = `
+           (try
+             (do (call $gc)
+                 (throw $exn))
+             (delegate 0))`;
+  let delegate1 = `
+           (block
+             (try
+               (do (call $gc)
+                   (throw $exn))
+               (delegate 1)))`;
+  let delegate0InCatch = `
+            (try
+              (do (throw $exn))
+              (catch_all
+                (try
+                  (do (call $gc)
+                      (throw $exn))
+                  (delegate 0))))`;
+  let delegate1InCatch = `
+            (try
+              (do (throw $exn))
+              (catch_all
+                (try
+                  (do (call $gc)
+                      (throw $exn))
+                  (delegate 1))))`;
+
+  let rethrowingBodies = [catchlessTry, rethrow0, delegate0, delegate1,
+                          rethrow1, delegate0InCatch, delegate1InCatch];
+
+  function rethrowingIndirectly(rethrowingBody) {
+    let exports = wasmEvalText(
+      `(module
+         (tag $exn (export "exn"))
+         (import "js" "gc" (func $gc))
+         (func $throwExn (export "throwExn") ${rethrowingBody}))`,
+      {js: {gc: () => { gc(); }}}
+    ).exports;
+
+    let mod =
+        `(module
+           (type $exnType (func))
+           (type $indirectFunctype (func))
+           (import "m" "exn" (tag $exn (type $exnType)))
+           (import "m" "throwExn" (func $throwExn (type $indirectFunctype)))
+           (table funcref (elem $throwExn))
+           (func (export "testFunc") (result i32)
+             (try (result i32)
+               (do (call_indirect (type $indirectFunctype) (i32.const 0))
+                   (i32.const 0))
+               (catch $exn (i32.const 1)))))`;
+
+    let testFunction = wasmEvalText(mod, { m : exports}).exports.testFunc;
+    assertEq(testFunction(), 1);
+  };
+
+  for (let rethrowingBody of rethrowingBodies) {
+    //console.log("Calling rethrowingIndirectly with rethrowingBody = " + rethrowingBody);
+    rethrowingIndirectly(rethrowingBody);
+  }
+}
+
+// The full test case that caused the original failure.
+
+{
+  gczeal(2,1); // Collect after every allocation.
+
+  let v128Type = " i32";
+  let wrongV128 = "(i32.const 0)";
+  let correctV128 = "(i32.const 1)";
+  let checkV128Value = "";
+
+  if (wasmSimdEnabled()) {
+    v128Type = " v128";
+    wrongV128 = "(v128.const i32x4 11 22 33 44)";
+    correctV128 = "(v128.const i32x4 55 66 77 88)";
+    checkV128Value = `;; Check the V128 value
+               (v128.const i32x4 55 66 77 88)
+               (i32x4.eq)
+               (i32x4.all_true)`;
+  }
+
+  let exports = wasmEvalText(
+    `(module
+       (type $exnType (func (param i32 i64 f32 f64 externref ${v128Type})))
+       (type $indirectFunctype (func (param i32 i64 f32 f64 externref ${v128Type})
+                                     (result i32 i64 f32 f64 externref ${v128Type})))
+       (tag $exn (export "exn") (type $exnType))
+       (tag $emptyExn (export "emptyExn"))
+       (func $throwExn (export "throwExn") (param i32 i64 f32 f64 externref ${v128Type})
+                                           (result i32 i64 f32 f64 externref ${v128Type})
+                                           (local $ifPredicate i32)
+         (local.get 0) ;; i32
+         (local.get 1) ;; i64
+         (local.get 2) ;; f32
+         (local.get 3) ;; f64
+         (local.get 4) ;; ref
+         (local.get 5) ;; v128 or i32
+         (try (param i32 i64 f32 f64 externref ${v128Type})
+           (do
+             (if (param i32 i64 f32 f64 externref ${v128Type})
+               (local.get $ifPredicate)
+               (then (throw $exn))
+               (else (throw $exn))))
+           (catch $exn
+              (try (param i32 i64 f32 f64 externref ${v128Type})
+                (do (throw $exn))
+                (catch_all (rethrow 1))))
+           (catch_all))
+           unreachable)
+         (func $throwEmptyExn (export "throwEmptyExn")
+                              (param i32 i64 f32 f64 externref ${v128Type})
+                              (result i32 i64 f32 f64 externref ${v128Type})
+           (throw $emptyExn)
+           unreachable)
+         (func $returnArgs (export "returnArgs")
+                           (param i32 i64 f32 f64 externref ${v128Type})
+                           (result i32 i64 f32 f64 externref ${v128Type})
+           (local.get 0)  ;; i32
+           (local.get 1)  ;; i64
+           (local.get 2)  ;; f32
+           (local.get 3)  ;; f64
+           (local.get 4)  ;; ref
+           (local.get 5))
+         (table (export "tab") funcref (elem $throwExn       ;; 0
+                                             $throwEmptyExn  ;; 1
+                                             $returnArgs))   ;; 2
+         )`).exports;
+
+  var mod =
+      `(module
+         (type $exnType (func (param i32 i64 f32 f64 externref ${v128Type})))
+         (type $indirectFunctype (func (param i32 i64 f32 f64 externref ${v128Type})
+                                 (result i32 i64 f32 f64 externref ${v128Type})))
+         (import "m" "exn" (tag $exn (type $exnType)))
+         (import "m" "emptyExn" (tag $emptyExn))
+         (import "m" "throwExn" (func $throwExn (type $indirectFunctype)))
+         (import "m" "throwEmptyExn"
+                 (func $throwEmptyExn (type $indirectFunctype)))
+         (import "m" "returnArgs"
+                 (func $returnArgs (type $indirectFunctype)))
+         (import "m" "tab" (table 3 funcref))
+         (func (export "testFunc") (param $correctRef externref)
+                                   (param $wrongRef externref)
+                                   ;; The last i32 result is the v128 check.
+                                   (result i32 i64 f32 f64 externref i32)
+                                   (local $ifPredicate i32)
+           (try (result i32 i64 f32 f64 externref i32)
+             (do
+               ;; Wrong values
+               (i32.const 5)
+               (i64.const 6)
+               (f32.const 0.1)
+               (f64.const 0.6437)
+               (local.get $wrongRef)
+               ${wrongV128}
+               ;; throwEmptyExn
+               (call_indirect (type $indirectFunctype) (i32.const 1))
+               drop ;; Drop the last v128 value.
+               (i32.const 0))
+             (catch_all
+               (try (result i32 i64 f32 f64 externref ${v128Type})
+                 (do ;; Values to throw.
+                   (i32.const 2)
+                   (i64.const 3)
+                   (f32.const 4)
+                   (f64.const 13.37)
+                   (local.get $correctRef)
+                   ${correctV128}
+                   (call_indirect (type $indirectFunctype) (i32.const 2)) ;; returnArgs
+                   (call_indirect (type $indirectFunctype) (i32.const 0)) ;; throwExn
+                   drop drop ;; Drop v128 and externref to do trivial and irrelevant ops.
+                   (f64.const 5)
+                   (f64.add)
+                   (local.get $wrongRef)
+                   ${wrongV128}
+                   ;; throwEmptyExn
+                   (call_indirect (type $indirectFunctype) (i32.const 1))
+                   unreachable)
+                 (catch $emptyExn
+                    ;; Wrong values
+                    (i32.const 5)
+                    (i64.const 6)
+                    (f32.const 0.1)
+                    (f64.const 0.6437)
+                    (local.get $wrongRef)
+                    ${wrongV128})
+                 (catch $exn)
+                 (catch_all
+                   ;; Wrong values
+                   (i32.const 5)
+                   (i64.const 6)
+                   (f32.const 0.1)
+                   (f64.const 0.6437)
+                   (local.get $wrongRef)
+                   ${wrongV128}))
+               ${checkV128Value}))))`;
+
+  let testAllValtypes = wasmEvalText(mod, { m : exports}).exports.testFunc;
+  assertEqArray(testAllValtypes("foo", "bar"),
+                [2, 3n, 4, 13.37, "foo", 1]);
+}
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1744663.js b/js/src/jit-test/tests/wasm/exceptions/bug-1744663.js
new file mode 100644
index 0000000000..a63dc24e19
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1744663.js
@@ -0,0 +1,63 @@
+gczeal(2,1);
+
+function failureCallingTestFunction() {
+  let exports = wasmEvalText(
+    `(module
+       (tag $exn (export "exn"))
+       (func $throwExn (export "throwExn")
+         ;; Note that this does not fail if this function body is a plain (throw $exn).
+         (try
+           (do (throw $exn)))))`
+  ).exports;
+
+  let mod =
+      `(module
+         (type $exnType (func))
+         (type $indirectFunctype (func))
+         (import "m" "exn" (tag $exn (type $exnType)))
+         (import "m" "throwExn" (func $throwExn (type $indirectFunctype)))
+         (table funcref (elem $throwExn))
+         (func (export "testFunc") (result i32)
+           (try
+             (do (call_indirect (type $indirectFunctype) (i32.const 0)))
+             (catch_all))
+           (i32.const 1)))`;
+
+  let testFunction = wasmEvalText(mod, { m : exports}).exports.testFunc;
+  testFunction();
+};
+
+function failureRethrow1() {
+  let exports = wasmEvalText(
+    `(module
+       (tag $exn (export "exn"))
+       (func $throwExn (export "throwExn")
+         (try
+           (do (throw $exn))
+           (catch_all
+             (try
+               (do (throw $exn))
+               (catch_all (rethrow 1)))))))`
+  ).exports;
+
+  let mod =
+      `(module
+         (type $exnType (func))
+         (type $indirectFunctype (func))
+         (import "m" "exn" (tag $exn (type $exnType)))
+         (import "m" "throwExn" (func $throwExn (type $indirectFunctype)))
+         (table funcref (elem $throwExn))
+         (func (export "testFunc") (result i32)
+           (try
+             (do (call_indirect (type $indirectFunctype) (i32.const 0)))
+             (catch_all))
+           (i32.const 1)))`;
+
+  let testFunction = wasmEvalText(mod, { m : exports}).exports.testFunc;
+  testFunction();
+};
+
+console.log("Calling failureCallingTestFunction.");
+failureCallingTestFunction();
+console.log("Calling failureRethrow1.");
+failureRethrow1();
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1747562.js b/js/src/jit-test/tests/wasm/exceptions/bug-1747562.js
new file mode 100644
index 0000000000..e54b860664
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1747562.js
@@ -0,0 +1,35 @@
+let bytes = wasmTextToBinary(`(module
+  (type (;0;) (func))
+  (func (;0;) (type 0)
+    block  ;; label = @1
+      try  ;; label = @2
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+        call 0
+      delegate 0
+    end)
+  (export "" (func 0)))`);
+let module = new WebAssembly.Module(bytes);
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1747704.js b/js/src/jit-test/tests/wasm/exceptions/bug-1747704.js
new file mode 100644
index 0000000000..f9f4292961
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1747704.js
@@ -0,0 +1,14 @@
+let {shouldTrap} = wasmEvalText(`(module
+  (func
+    try
+      i32.const 0
+      table.get 0
+      ref.is_null
+      drop
+    catch_all
+    end
+  )
+  (table 0 funcref)
+  (export "shouldTrap" (func 0))
+)`).exports;
+assertErrorMessage(shouldTrap, WebAssembly.RuntimeError, /table index/);
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1751699.js b/js/src/jit-test/tests/wasm/exceptions/bug-1751699.js
new file mode 100644
index 0000000000..38268e7905
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1751699.js
@@ -0,0 +1,8 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+oomTest(() => {
+	wasmEvalText(`
+      (import "" "" (func $d))
+      (func try call $d end)
+    `);
+});
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1767446.js b/js/src/jit-test/tests/wasm/exceptions/bug-1767446.js
new file mode 100644
index 0000000000..5cf38a757c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1767446.js
@@ -0,0 +1,26 @@
+// Dead code elimination can remove wasm calls that may leave behind dangling
+// try notes.
+wasmEvalText(`(module
+  (type (;0;) (func (result i32 i32 i32)))
+  (func $main (type 0) (result i32 i32 i32)
+    try (result i32 i32 i32)  ;; label = @1
+      call $main
+      call $main
+      i32.const 541
+      i32.const 0
+      br_if 0 (;@1;)
+      br_if 0 (;@1;)
+      br_if 0 (;@1;)
+      br_if 0 (;@1;)
+      call $main
+      call $main
+      br_if 0 (;@1;)
+      br_if 0 (;@1;)
+      call $main
+      call $main
+      call $main
+      unreachable
+    end
+    unreachable
+  )
+)`);
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1788213.js b/js/src/jit-test/tests/wasm/exceptions/bug-1788213.js
new file mode 100644
index 0000000000..4d0b4abcdc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1788213.js
@@ -0,0 +1,5 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+oomTest(() => {
+	wasmEvalText(`(import "" "" (tag $undef)) (func throw 0) (func (try (do)))`);
+});
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1791361.js b/js/src/jit-test/tests/wasm/exceptions/bug-1791361.js
new file mode 100644
index 0000000000..9c4432de91
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1791361.js
@@ -0,0 +1,12 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+oomTest(() => {
+    wasmEvalText(`
+      (tag $d)
+      (func $anotherLocalFuncThrowsExn)
+      (func throw $d)
+      (func (try (do
+        call $anotherLocalFuncThrowsExn
+      )))
+    `);
+});
diff --git a/js/src/jit-test/tests/wasm/exceptions/bug-1797685.js b/js/src/jit-test/tests/wasm/exceptions/bug-1797685.js
new file mode 100644
index 0000000000..d2f02a8fd6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/bug-1797685.js
@@ -0,0 +1,8 @@
+assertErrorMessage(() => wasmEvalText(`(module
+  (func)
+  (func
+    try
+      call 0
+    delegate 4294967295
+  )
+)`), WebAssembly.CompileError, /delegate/);
diff --git a/js/src/jit-test/tests/wasm/exceptions/caching.js b/js/src/jit-test/tests/wasm/exceptions/caching.js
new file mode 100644
index 0000000000..5427de5102
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/caching.js
@@ -0,0 +1,28 @@
+// |jit-test| skip-if: !wasmCachingEnabled()
+
+load(libdir + "wasm-caching.js");
+
+// Test that the tag section is cached correctly
+testCached(`(module
+	(tag $t (export "t"))
+	(func (export "r")
+		throw $t
+	)
+)`, {}, i => {
+	assertErrorMessage(() => i.exports.r(), WebAssembly.Exception, /.*/);
+});
+
+// Test that try notes are cached correctly
+testCached(`(module
+	(tag $t)
+	(func (export "r") (result i32)
+		try (result i32)
+			throw $t
+			i32.const 0
+		catch $t
+			i32.const 1
+		end
+	)
+)`, {}, i => {
+	assertEq(i.exports.r(), 1, "caught");
+});
diff --git a/js/src/jit-test/tests/wasm/exceptions/calls.js b/js/src/jit-test/tests/wasm/exceptions/calls.js
new file mode 100644
index 0000000000..f12e5d1dbe
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/calls.js
@@ -0,0 +1,407 @@
+// -----------------------------------------------------------------------------
+// This file contains tests checking Wasm functions with throwing functions and
+// try-catch code involving more complex control flow, testing that multiple
+// values returned from calls in try code are not affected by multiple branching
+// towards the landing pad, as well as making sure exceptions carrying multiple
+// values of any Wasm numtype transport the exception values correctly across
+// calls.
+//
+// There are tests for local direct calls, for imported direct calls, for
+// indirect calls in a local table with local functions, for indirect calls in a
+// local table of imported functions, and for indirect calls in an imported
+// table of imported functions.
+//
+// - TODO: Add reftype values, when support for reftypes in exceptions is
+//   implemented.
+// -----------------------------------------------------------------------------
+
+load(libdir + "eqArrayHelper.js");
+
+// All individual tests take a string 'localThrow' as argument, and will be run
+// with each element of the result of the following function.
+
+function generateLocalThrows(types, baseThrow) {
+  // Arguments:
+  // - 'types': A string of space separated Wasm types.
+  // - 'baseThrow': A string with a Wasm instruction sequence of Wasm functype
+  //                `[${types}]-> [t*], which takes `types` arguments and ends
+  //                up throwing the tag '$exn'.
+  // Result:
+  // - A JS array of strings, each representing a Wasm instruction sequence
+  //   which is like `baseThrow', i.e., a Wasm instruction sequence of Wasm
+  //   functype `[${types}]-> [t*], which takes `types` arguments and ends up
+  //   throwing the tag '$exn'. The result does not include 'baseThrow'.
+  //
+  // All strings in Wasm text format.
+
+  // Basic throws;
+  let catchlessTryThrow =
+      `(try (param ${types})
+         (do ${baseThrow}))`;
+
+  let catchAndThrow =
+      `(try (param ${types})
+         (do ${baseThrow})
+         (catch $exn
+           ${baseThrow})
+         (catch_all))`;
+
+  let blockThrow =
+      `(block (param ${types})
+         ${baseThrow})`;
+
+  // This Wasm code requires that the function it appears in has an i32 local
+  // with name "$ifPredicate".
+  let conditionalThrow =
+      `(if (param ${types})
+         (local.get $ifPredicate)
+         (then ${baseThrow})
+         (else ${baseThrow}))`;
+
+  // Including try-delegate.
+  let baseDelegate =
+      `(try (param ${types})
+         (do ${baseThrow})
+         (delegate 0))`;
+
+  // Delegate just outside the block.
+  let nestedDelegate1InBlock =
+      `(block $label1 (param ${types})
+         (try (param ${types})
+           (do ${baseThrow})
+           (delegate $label1)))`;
+
+  let basicThrows = [catchlessTryThrow, blockThrow, conditionalThrow,
+                     baseDelegate, nestedDelegate1InBlock];
+
+  // Secondary throws (will end up inside a catch block).
+
+  let baseRethrow =
+      `(rethrow 0)`;
+
+  let nestedRethrow =
+      `(try (param ${types})
+         (do
+           ${baseThrow})
+         (catch $exn
+           (rethrow 1))
+         (catch_all
+           (rethrow 0)))`;
+
+  let catchAllRethrowOriginal =
+      `(try (param ${types})
+         (do
+           ${baseThrow})
+         (catch_all
+           (rethrow 1)))`;
+
+  let secondaryThrows =
+      [].concat(basicThrows,
+                [baseRethrow, nestedRethrow, catchAllRethrowOriginal]);
+
+  // Nestings.
+
+  function basicNesting (basicThrow, secondaryThrow) {
+    return `(try (param ${types})
+              (do ${basicThrow})
+              (catch $exn
+                ${secondaryThrow})
+              (catch_all))`;
+  };
+
+  let result = [];
+
+  for (let basicThrow of basicThrows) {
+    result.push(basicThrow);
+    for (let secondaryThrow of secondaryThrows) {
+      result.push(basicNesting(basicThrow, secondaryThrow));
+    }
+  }
+
+  return result;
+};
+
+{
+  // Some variables to be used in all tests.
+  let typesJS = ["i32", "i64", "f32", "f64", "externref"];
+  let types = typesJS.join(" ");
+
+  // The following depend on whether simd is enabled or not. We write it like
+  // this so we can run this test also when SIMD is not enabled.
+  let exntype = "";
+  let wrongV128 = "";
+  let throwV128 = "";
+  let checkV128Value = "";
+
+  if (wasmSimdEnabled()) {
+    exntype = types + " v128";
+    wrongV128 = `(v128.const i32x4 11 22 33 44)`;
+    throwV128 = `(v128.const i32x4 55 66 77 88)`;
+    checkV128Value = `;; Check the V128 value
+             ${throwV128}
+             (i32x4.eq)
+             (i32x4.all_true)`;
+  } else {
+    exntype = types + " i32";
+    wrongV128 = "(i32.const 0)";
+    throwV128 = "(i32.const 1)";
+    checkV128Value = "";
+  }
+
+  let exnTypeDef = `(type $exnType (func (param ${exntype})))`;
+
+  let throwValues =
+      `;; Values to throw.
+               (i32.const 2)
+               (i64.const 3)
+               (f32.const 4)
+               (f64.const 13.37)
+               (local.get $correctRef)
+               ${throwV128}`;
+
+  // The last 1 is the result of the test that the v128 value is correct, done
+  // in wasm code (if simd is enabled).
+  let correctResultsJS = [2, 3n, 4, 13.37, "foo", 1];
+
+  let wrongValues =
+      `;; Wrong values
+                    (i32.const 5)
+                    (i64.const 6)
+                    (f32.const 0.1)
+                    (f64.const 0.6437)
+                    (local.get $wrongRef)
+                    ${wrongV128}`;
+
+  // The individual tests. -----------------------------------------------------
+
+  function testDirectCallsThrowing(localThrow) {
+    // Test direct function calls throwing any numeric value.
+
+    let throwifTypeInline =
+        // The result of the "throwif" function will be used as an argument the
+        // second time "throwif" is called.
+        `(param $ifPredicate i32) (param $correctRef externref) (result i32)`;
+
+    let moduleHeaderThrowif =
+        `(module
+           ${exnTypeDef}
+           (tag $exn (export "exn") (type $exnType))
+           (func $throwif (export "throwif") ${throwifTypeInline}
+             (if
+               (local.get $ifPredicate)
+               (then
+                 ${throwValues}
+                 ${localThrow}))
+             (i32.const 1))`;
+
+    let testModuleRest =
+        `(tag $notThrownExn)
+         (func $doNothing)
+         (func (export "testFunc") (param $correctRef externref)
+                                   (param $wrongRef externref)
+                                   (result ${types} i32)
+                                   (local $ifPredicate i32)
+           (local.get $ifPredicate)
+           (try (param i32) (result ${exntype})
+             (do
+               (local.get $wrongRef)
+               (call $throwif) ;; Returns 1.
+               (call $doNothing) ;; Does nothing.
+               (local.get $correctRef)
+               (call $throwif) ;; Throws $exn.
+               (drop)
+               ${wrongValues} ;; Won't reach this point.
+               ${localThrow}
+               unreachable)
+             (catch $notThrownExn
+               ${wrongValues})
+             (catch $exn))
+           ${checkV128Value}))`;
+
+    function testDirectLocalCallsThrowing() {
+      let mod = moduleHeaderThrowif + testModuleRest;
+      // console.log("DIRECT LOCAL MOD = " + mod);  // Uncomment for debugging.
+
+      assertEqArray(wasmEvalText(mod).exports.testFunc("foo", "bar"),
+                    correctResultsJS);
+    };
+
+    function testDirectImportedCallsThrowing() {
+      let exports = wasmEvalText(moduleHeaderThrowif + `)`).exports;
+      // Uncomment for debugging.
+      //console.log("DIRECT EXPORTS = " + moduleHeaderThrowif + ")");
+
+      let mod =
+          `(module
+             ${exnTypeDef}
+             (import "m" "exn" (tag $exn (type $exnType)))
+             (import "m" "throwif" (func $throwif ${throwifTypeInline}))` +
+          testModuleRest;
+      // console.log("DIRECT IMPORT MOD = " + mod); // Uncomment for debugging.
+
+      assertEqArray(
+        wasmEvalText(mod, { m : exports}).exports.testFunc("foo", "bar"),
+        correctResultsJS);
+    };
+
+    testDirectLocalCallsThrowing();
+    testDirectImportedCallsThrowing();
+  };
+
+  function testIndirectCallsThrowing(localThrow) {
+    // Test indirect calls throwing exceptions.
+
+    let indirectFunctypeInline = `(param ${exntype})
+                                  (result ${exntype})`;
+    let getIndirectArgs = `(local.get 0) ;; i32
+             (local.get 1) ;; i64
+             (local.get 2) ;; f32
+             (local.get 3) ;; f64
+             (local.get 4) ;; ref
+             ;; v128
+             (local.get 5)`;
+
+    let testFunctypeInline = `(param $correctRef externref)
+                                     (param $wrongRef externref)
+                                     ;; The last i32 result is the v128 check.
+                                     (result ${types} i32)`;
+
+    let moduleHeader =
+        `(module
+           ${exnTypeDef}
+           (type $indirectFunctype (func ${indirectFunctypeInline}))
+           (tag $exn (export "exn") (type $exnType))
+           (tag $emptyExn (export "emptyExn"))
+           (func $throwExn (export "throwExn") ${indirectFunctypeInline}
+                                               (local $ifPredicate i32)
+             ${getIndirectArgs}
+             ${localThrow}
+             unreachable)
+           (func $throwEmptyExn (export "throwEmptyExn")
+                                ${indirectFunctypeInline}
+             (throw $emptyExn)
+             unreachable)
+           (func $returnArgs (export "returnArgs") ${indirectFunctypeInline}
+             ${getIndirectArgs})
+           (table (export "tab") funcref (elem $throwExn       ;; 0
+                                               $throwEmptyExn  ;; 1
+                                               $returnArgs))   ;; 2
+           `;
+
+    // The main test function happens to have the same Wasm functype as the
+    // indirect calls.
+    let testFuncHeader = `(func (export "testFunc") ${testFunctypeInline}
+                                     (local $ifPredicate i32)
+             `;
+
+    // To test indirect calls to a local table of local functions
+    function moduleIndirectLocalLocal(functionBody) {
+      return moduleHeader + testFuncHeader + functionBody + `))`;
+    };
+
+    let exports = wasmEvalText(moduleHeader + ")").exports;
+    // Uncomment for debugging.
+    //console.log("INDIRECT EXPORTS = " + moduleHeader + ")");
+
+    let moduleHeaderImporting =
+        `(module
+           ${exnTypeDef}
+           (type $indirectFunctype (func ${indirectFunctypeInline}))
+           (import "m" "exn" (tag $exn (type $exnType)))
+           (import "m" "emptyExn" (tag $emptyExn))
+           (import "m" "throwExn" (func $throwExn (type $indirectFunctype)))
+           (import "m" "throwEmptyExn"
+                   (func $throwEmptyExn (type $indirectFunctype)))
+           (import "m" "returnArgs"
+                   (func $returnArgs (type $indirectFunctype)))`;
+
+    // To test indirect calls to a local table of imported functions.
+    function moduleIndirectLocalImport(functionBody) {
+      return moduleHeaderImporting +
+        `(table funcref (elem $throwExn $throwEmptyExn $returnArgs))` +
+        testFuncHeader + functionBody + `))`;
+    };
+
+    // To test indirect calls to an imported table of imported functions.
+    function moduleIndirectImportImport(functionBody) {
+      return moduleHeaderImporting +
+        `(import "m" "tab" (table 3 funcref))` +
+        testFuncHeader + functionBody + `))`;
+    };
+
+    function getModuleTextsForFunctionBody(functionBody) {
+      return [moduleIndirectLocalLocal(functionBody),
+              moduleIndirectLocalImport(functionBody),
+              moduleIndirectImportImport(functionBody)];
+    };
+
+    // The function bodies for the tests.
+
+    // Three indirect calls, the middle of which throws and will be caught. The
+    // results of the first and second indirect calls are used by the next
+    // indirect call. This should be called from try code, to check that the
+    // pad-branches don't interfere with the results of each call.
+    let indirectThrow = `${throwValues}
+               (call_indirect (type $indirectFunctype) (i32.const 2)) ;; returnArgs
+               (call_indirect (type $indirectFunctype) (i32.const 0)) ;; throwExn
+               drop drop ;; Drop v128 and externref to do trivial and irrelevant ops.
+               (f64.const 5)
+               (f64.add)
+               (local.get $wrongRef)
+               ${wrongV128}
+               ;; throwEmptyExn
+               (call_indirect (type $indirectFunctype) (i32.const 1))
+               unreachable`;
+
+    // Simple try indirect throw and catch.
+    let simpleTryIndirect = `(try (result ${exntype})
+              (do ${indirectThrow})
+              (catch $emptyExn
+                 ${wrongValues})
+              (catch $exn)
+              (catch_all
+                 ${wrongValues}))
+              ${checkV128Value}`;
+
+    // Indirect throw/catch_all, with a simple try indirect throw nested in the
+    // catch_all.
+    let nestedTryIndirect =
+        `(try (result ${types} i32)
+           (do
+             ${wrongValues}
+             ;; throwEmptyExn
+             (call_indirect (type $indirectFunctype) (i32.const 1))
+             drop ;; Drop the last v128 value.
+             (i32.const 0))
+           (catch_all
+             ${simpleTryIndirect}))`;
+
+    let functionBodies = [simpleTryIndirect, nestedTryIndirect];
+
+    // Test throwing from indirect calls.
+    for (let functionBody of functionBodies) {
+      console.log("functionBody = : " + functionBody); // Uncomment for debugging.
+
+      for (let mod of getModuleTextsForFunctionBody(functionBody)) {
+        //console.log("mod = : " + mod); // Uncomment for debugging.
+
+        let testFunction = wasmEvalText(mod, { m : exports}).exports.testFunc;
+        assertEqArray(testFunction("foo", "bar"),
+                      correctResultsJS);
+      }
+    }
+  };
+
+  // Run all tests. ------------------------------------------------------------
+
+  let localThrows =
+      ["(throw $exn)"].concat(generateLocalThrows(exntype, "(throw $exn)"));
+
+  for (let localThrow of localThrows) {
+    // Uncomment for debugging.
+    //console.log("Testing with localThrow = " + localThrow);
+
+    testDirectCallsThrowing(localThrow);
+    testIndirectCallsThrowing(localThrow);
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/exceptions/directives.txt b/js/src/jit-test/tests/wasm/exceptions/directives.txt
new file mode 100644
index 0000000000..b8ee0d8d7c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/directives.txt
@@ -0,0 +1 @@
+|jit-test| --wasm-exceptions; test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; include:wasm.js; skip-if: !wasmExceptionsEnabled()
diff --git a/js/src/jit-test/tests/wasm/exceptions/events.js b/js/src/jit-test/tests/wasm/exceptions/events.js
new file mode 100644
index 0000000000..00bb244546
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/events.js
@@ -0,0 +1,160 @@
+// Tests for tag section support
+
+load(libdir + "wasm-binary.js");
+
+function wasmEval(code, imports) {
+  new WebAssembly.Instance(new WebAssembly.Module(code), imports).exports;
+}
+
+function wasmError(code, errorType, regexp) {
+  assertErrorMessage(() => wasmEval(code, {}), errorType, regexp);
+}
+
+const emptyType = { args: [], ret: VoidCode };
+const badExnType = { args: [], ret: I32Code };
+
+wasmEvalText(`
+  (module
+    (type (func (param i32)))
+    (tag $exn (type 0)))
+`);
+
+wasmError(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    { name: tagId, body: [] },
+  ]),
+  WebAssembly.CompileError,
+  /expected number of tags/
+);
+
+wasmError(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    { name: tagId, body: [1, 1] },
+  ]),
+  WebAssembly.CompileError,
+  /illegal tag kind/
+);
+
+wasmError(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    { name: tagId, body: [1, 0] },
+  ]),
+  WebAssembly.CompileError,
+  /expected function index in tag/
+);
+
+wasmEval(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    tagSection([{ type: 0 }]),
+  ])
+);
+
+wasmError(
+  moduleWithSections([
+    sigSection([badExnType]),
+    memorySection(0),
+    tagSection([{ type: 0 }]),
+  ]),
+  WebAssembly.CompileError,
+  /tag function types must not return anything/
+);
+
+wasmError(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    tagSection([{ type: 1 }]),
+  ]),
+  WebAssembly.CompileError,
+  /function type index in tag out of bounds/
+);
+
+wasmError(
+  moduleWithSections([
+    sigSection([emptyType]),
+    tagSection([{ type: 0 }]),
+    memorySection(0),
+  ]),
+  WebAssembly.CompileError,
+  /expected custom section/
+);
+
+(() => {
+  const body = [1];
+  body.push(...string("mod"));
+  body.push(...string("exn"));
+  body.push(...varU32(TagCode));
+
+  wasmError(
+    moduleWithSections([
+      sigSection([emptyType]),
+      { name: importId, body: body },
+    ]),
+    WebAssembly.CompileError,
+    /expected tag kind/
+  );
+
+  body.push(...varU32(0));
+  wasmError(
+    moduleWithSections([
+      sigSection([emptyType]),
+      { name: importId, body: body },
+    ]),
+    WebAssembly.CompileError,
+    /expected function index in tag/
+  );
+
+  body.push(...varU32(1));
+  wasmError(
+    moduleWithSections([
+      sigSection([emptyType]),
+      { name: importId, body: body },
+    ]),
+    WebAssembly.CompileError,
+    /function type index in tag out of bounds/
+  );
+})();
+
+wasmEval(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    tagSection([{ type: 0 }]),
+    exportSection([{ tagIndex: 0, name: "exn" }]),
+  ])
+);
+
+wasmError(
+  moduleWithSections([
+    sigSection([emptyType]),
+    memorySection(0),
+    tagSection([{ type: 0 }]),
+    exportSection([{ tagIndex: 1, name: "exn" }]),
+  ]),
+  WebAssembly.CompileError,
+  /exported tag index out of bounds/
+);
+
+(() => {
+  const body = [1];
+  body.push(...string("exn"));
+  body.push(...varU32(TagCode));
+  wasmError(
+    moduleWithSections([
+      sigSection([emptyType]),
+      memorySection(0),
+      tagSection([{ type: 0 }]),
+      { name: exportId, body: body },
+    ]),
+    WebAssembly.CompileError,
+    /expected tag index/
+  );
+})();
diff --git a/js/src/jit-test/tests/wasm/exceptions/example.js b/js/src/jit-test/tests/wasm/exceptions/example.js
new file mode 100644
index 0000000000..f1c9f144b9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/example.js
@@ -0,0 +1,28 @@
+// A diagram depicting the control flow graph of the function g below can be
+// found in "js/src/wasm/WasmIonCompile.cpp". If you make any changes to this
+// test file be sure to adjust the SMDOC documentation there as well.
+
+let g = wasmEvalText(
+  `(module
+     (tag $exn (param f64))
+     (func $f)
+     (func (export "g") (param $arg i32) (result f64)
+       (local.get $arg)
+       (try (param i32) (result f64)
+         (do
+           (if (result f64)
+             (then
+               (f64.const 3))
+             (else
+               (throw $exn (f64.const 6))))
+           (call $f)
+           (f64.sub (f64.const 2)))  ;; If $arg is 0 we end here, subtracting 3.
+         ;; If $arg is not 0 then the else-block throws $exn, caught below.
+         (catch $exn
+           (f64.add (f64.const 4)))  ;; Adds 4 to the value in the $exn (6).
+         (catch_all                  ;; This shouldn't occur.
+           (f64.const 5)))))`
+).exports.g;
+
+assertEq(g(0), 10);
+assertEq(g(1), 1);
diff --git a/js/src/jit-test/tests/wasm/exceptions/import-export.js b/js/src/jit-test/tests/wasm/exceptions/import-export.js
new file mode 100644
index 0000000000..fe7646678f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/import-export.js
@@ -0,0 +1,100 @@
+// Tests for Wasm exception import and export.
+
+function testImports() {
+  var mod = `
+    (module
+      (type (func (param i32 i32)))
+      (import "m" "exn" (tag (type 0))))
+ `;
+
+  assertErrorMessage(
+    () => wasmEvalText(mod, { m: { exn: "not a tag" } }),
+    WebAssembly.LinkError,
+    /import object field 'exn' is not a Tag/
+  );
+}
+
+function testExports() {
+  var exports1 = wasmEvalText(`
+    (module (type (func)) (tag (export "exn") (type 0)))
+  `).exports;
+
+  assertEq(typeof exports1.exn, "object");
+  assertEq(exports1.exn instanceof WebAssembly.Tag, true);
+
+  var exports2 = wasmEvalText(`
+    (module
+      (type (func (param i32 i32)))
+      (tag (export "exn") (type 0)))
+  `).exports;
+
+  assertEq(typeof exports2.exn, "object");
+  assertEq(exports2.exn instanceof WebAssembly.Tag, true);
+}
+
+function testImportExport() {
+  var exports = wasmEvalText(`
+    (module
+      (type (func (param i32)))
+      (tag (export "exn") (type 0)))
+  `).exports;
+
+  wasmEvalText(
+    `
+    (module
+      (type (func (param i32)))
+      (import "m" "exn" (tag (type 0))))
+  `,
+    { m: exports }
+  );
+
+  assertErrorMessage(
+    () => {
+      wasmEvalText(
+        `
+      (module
+        (type (func (param)))
+        (import "m" "exn" (tag (type 0))))
+    `,
+        { m: exports }
+      );
+    },
+    WebAssembly.LinkError,
+    /imported tag 'm.exn' signature mismatch/
+  );
+}
+
+// Test imports/exports descriptions.
+function testDescriptions() {
+  const imports = WebAssembly.Module.imports(
+    new WebAssembly.Module(
+      wasmTextToBinary(`
+        (module $m
+          (type (func))
+          (import "m" "e" (tag (type 0))))
+      `)
+    )
+  );
+
+  const exports = WebAssembly.Module.exports(
+    new WebAssembly.Module(
+      wasmTextToBinary(`
+        (module
+          (type (func))
+          (tag (export "e") (type 0)))
+      `)
+    )
+  );
+
+  assertEq(imports[0].module, "m");
+  assertEq(imports[0].name, "e");
+  assertEq(imports[0].kind, "tag");
+
+  assertEq(exports[0].name, "e");
+  assertEq(exports[0].kind, "tag");
+}
+
+testImports();
+testExports();
+testImportExport();
+testDescriptions();
diff --git a/js/src/jit-test/tests/wasm/exceptions/instructions.js b/js/src/jit-test/tests/wasm/exceptions/instructions.js
new file mode 100644
index 0000000000..a184b2e99e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/instructions.js
@@ -0,0 +1,1528 @@
+// Tests for Wasm exception proposal instructions.
+
+// Test try blocks with no handlers.
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         try (result i32) (i32.const 0) end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         try (result i32) (i32.const 0) (br 0) (i32.const 1) end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             (throw $exn)
+             (i32.const 1)
+           end
+           drop
+           (i32.const 2)
+         catch $exn
+           (i32.const 0)
+         end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try
+               try
+                 (throw $exn)
+               end
+             end
+             (i32.const 1)
+           end
+           drop
+           (i32.const 2)
+         catch $exn
+           (i32.const 0)
+         end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try
+               try
+                 (throw $exn)
+               end
+             catch_all
+               rethrow 0
+             end
+             (i32.const 1)
+           end
+           drop
+           (i32.const 2)
+         catch $exn
+           (i32.const 0)
+         end))`
+  ).exports.f(),
+  0
+);
+
+// Test trivial try-catch with empty bodies.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try nop catch $exn end
+         (i32.const 0)))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         try nop catch_all end
+         (i32.const 0)))`
+  ).exports.f(),
+  0
+);
+
+// Test try block with no throws
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 0)
+         catch $exn
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  0
+);
+
+// Ensure catch block is really not run when no throw occurs.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32) (local i32)
+         try
+           (local.set 0 (i32.const 42))
+         catch $exn
+           (local.set 0 (i32.const 99))
+         end
+         (local.get 0)))`
+  ).exports.f(),
+  42
+);
+
+// Simple uses of throw.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (throw $exn)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func $foo (param i32) (result i32)
+         (local.get 0) (throw $exn))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (call $foo)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Simple uses of throw of some Wasm vectortype values (Simd128).
+if (wasmSimdEnabled()) {
+  assertEq(
+    wasmEvalText(
+      `(module
+         (type (func (param v128 v128 v128 v128)))
+         (tag $exn (type 0))
+         (func (export "f") (result i32)
+           try (result i32)
+             (v128.const i32x4 42 41 40 39)
+             (v128.const f32x4 4.2 4.1 0.40 3.9)
+             (v128.const i64x2 42 41)
+             (v128.const f64x2 4.2 4.1)
+             (throw $exn)
+           catch $exn
+             drop drop drop
+             (i64x2.all_true)
+           end))`
+    ).exports.f(),
+    1
+  );
+
+  assertEq(
+    wasmEvalText(
+      `(module
+         (type (func (param v128 v128 v128 v128)))
+         (tag $exn (type 0))
+         (func $foo (param v128 v128 v128 v128) (result i32)
+           (throw $exn (local.get 0)
+                       (local.get 1)
+                       (local.get 2)
+                       (local.get 3)))
+         (func (export "f") (result i32)
+           try (result i32)
+             (v128.const i32x4 42 41 40 39)
+             (v128.const f32x4 4.2 4.1 0.40 3.9)
+             (v128.const i64x2 42 41)
+             (v128.const f64x2 4.2 4.1)
+             (call $foo)
+           catch $exn
+             drop drop drop
+             (i64x2.all_true)
+           end))`
+    ).exports.f(),
+    1
+  );
+
+  {
+    let imports =
+        wasmEvalText(
+          `(module
+             (tag $exn (export "exn") (param v128))
+             (func (export "throws") (param v128) (result v128)
+               (throw $exn (local.get 0))
+               (v128.const i32x4 9 10 11 12)))`).exports;
+
+    let mod =
+        `(module
+           (import "m" "exn" (tag $exn (param v128)))
+           (import "m" "throws" (func $throws (param v128) (result v128)))
+           (func (export "f") (result i32) (local v128)
+             (v128.const i32x4 1 2 3 4)
+             (local.tee 0)
+             (try (param v128) (result v128)
+               (do (call $throws))
+               (catch $exn)
+               (catch_all (v128.const i32x4 5 6 7 8)))
+             (local.get 0)
+             (i32x4.eq)
+             (i32x4.all_true)))`;
+
+    assertEq(wasmEvalText(mod, { m : imports }).exports.f(), 1);
+  }
+}
+
+// Further nested call frames should be ok.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func $foo (param i32) (result i32)
+         (local.get 0) (call $bar))
+       (func $bar (param i32) (result i32)
+         (local.get 0) (call $quux))
+       (func $quux (param i32) (result i32)
+         (local.get 0) (throw $exn))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (call $foo)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Basic throwing from loop.
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn)
+       ;; For the purpose of this test, the params below should be increasing.
+       (func (export "f") (param $depth_to_throw_exn i32)
+                          (param $maximum_loop_iterations i32)
+                          (result i32)
+                          (local $loop_counter i32)
+         ;; The loop is counting down.
+         (local.get $maximum_loop_iterations)
+         (local.set $loop_counter)
+         (block $catch
+           (loop $loop
+             (if (i32.eqz (local.get $loop_counter))
+                 (then
+                   (return (i32.const 440)))
+                 (else
+                   (try
+                     (do
+                       (if (i32.eq (local.get $depth_to_throw_exn)
+                                   (local.get $loop_counter))
+                         (then
+                           (throw $exn))
+                         (else
+                           (local.set $loop_counter
+                                      (i32.sub (local.get $loop_counter)
+                                               (i32.const 1))))))
+                     (catch $exn (br $catch))
+                     (catch_all))))
+               (br $loop))
+             (return (i32.const 10001)))
+         (i32.const 10000)))`
+  ).exports.f(2, 4),
+  10000
+);
+
+// Ensure conditional throw works.
+let conditional = wasmEvalText(
+  `(module
+     (type (func (param)))
+     (tag $exn (type 0))
+     (func (export "f") (param i32) (result i32)
+       try (result i32)
+         (local.get 0)
+         if (result i32)
+           (throw $exn)
+         else
+           (i32.const 42)
+         end
+       catch $exn
+         (i32.const 99)
+       end))`
+).exports.f;
+
+assertEq(conditional(0), 42);
+assertEq(conditional(1), 99);
+
+// Ensure multiple & nested try-catch blocks work.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func $foo (throw $exn))
+       (func (export "f") (result i32) (local i32)
+         try
+           nop
+         catch $exn
+           (local.set 0 (i32.const 99))
+         end
+         try
+           (call $foo)
+         catch $exn
+           (local.set 0 (i32.const 42))
+         end
+         (local.get 0)))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32) (local i32)
+         try
+           try
+             try
+               (throw $exn)
+             catch $exn
+               (local.set 0 (i32.const 42))
+             end
+           catch $exn
+             (local.set 0 (i32.const 97))
+           end
+         catch $exn
+           (local.set 0 (i32.const 98))
+         end
+         (local.get 0)))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn)
+       (func (export "f") (result i32)
+         (try
+           (do throw $exn)
+           (catch $exn
+             (try
+               (do (throw $exn))
+               (catch $exn))))
+         (i32.const 27)))`
+  ).exports.f(),
+  27
+);
+
+{
+  let nested_throw_in_block_and_in_catch =
+      wasmEvalText(
+        `(module
+           (tag $exn)
+           (func $throw
+             (throw $exn))
+           (func (export "f") (param $arg i32) (result i32)
+             (block (result i32)
+               (try (result i32)
+                 (do
+                   (call $throw)
+                   (unreachable))
+                 (catch $exn
+                   (if (result i32)
+                     (local.get $arg)
+                     (then
+                       (try (result i32)
+                         (do
+                           (call $throw)
+                           (unreachable))
+                         (catch $exn
+                           (i32.const 27))))
+                     (else
+                       (i32.const 11))))))))`
+      ).exports.f;
+
+  assertEq(nested_throw_in_block_and_in_catch(1), 27);
+  assertEq(nested_throw_in_block_and_in_catch(0), 11);
+}
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $thrownExn)
+       (tag $notThrownExn)
+       (func (export "f") (result i32)
+         (try (result i32)
+           (do
+             (try (result i32)
+               (do (throw $thrownExn))
+               (catch $notThrownExn
+                 (i32.const 19))
+               (catch $thrownExn
+                 (i32.const 20))
+               (catch_all
+                 (i32.const 21)))))))`
+  ).exports.f(),
+  20
+);
+
+// Test that uncaught exceptions get propagated.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $thrownExn)
+       (tag $notThrownExn)
+       (func (export "f") (result i32) (local i32)
+         (try
+           (do
+             (try
+               (do
+                 (try
+                   (do (throw $thrownExn))
+                   (catch $notThrownExn
+                     (local.set 0
+                       (i32.or (local.get 0)
+                               (i32.const 1))))))
+               (catch $notThrownExn
+                 (local.set 0
+                   (i32.or (local.get 0)
+                           (i32.const 2))))))
+           (catch $thrownExn
+             (local.set 0
+               (i32.or (local.get 0)
+                       (i32.const 4)))))
+         (local.get 0)))`
+  ).exports.f(),
+  4
+);
+
+// Test tag dispatch for catches.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn1
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         catch $exn3
+           i32.const 3
+         end))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn2
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         catch $exn3
+           i32.const 3
+         end))`
+  ).exports.f(),
+  2
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn3
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         catch $exn3
+           i32.const 3
+         end))`
+  ).exports.f(),
+  3
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (tag $exn3 (type 0))
+       (tag $exn4 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             throw $exn4
+           catch $exn1
+             i32.const 1
+           catch $exn2
+             i32.const 2
+           catch $exn3
+             i32.const 3
+           end
+         catch $exn4
+           i32.const 4
+         end))`
+  ).exports.f(),
+  4
+);
+
+// Test usage of br before a throw.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (i32.const 2)
+           (br $l)
+           (throw $exn)
+         catch $exn
+           drop
+           (i32.const 1)
+         end))`
+  ).exports.f(),
+  2
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (throw $exn)
+         catch $exn
+           (i32.const 2)
+           (br $l)
+           rethrow 0
+         end))`
+  ).exports.f(),
+  2
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (throw $exn)
+         catch_all
+           (i32.const 2)
+           (br $l)
+           rethrow 0
+         end))`
+  ).exports.f(),
+  2
+);
+
+// Test br branching out of a catch block.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         block $l (result i32)
+           block (result i32)
+             try (result i32)
+               (i32.const 42)
+               (throw $exn)
+             catch $exn
+               br $l
+               (i32.const 99)
+             end
+           end
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Test dead catch block.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         i32.const 0
+         return
+         try nop catch $exn end))`
+  ).exports.f(),
+  0
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result i32)
+         i32.const 0
+         return
+         try nop catch_all end))`
+  ).exports.f(),
+  0
+);
+
+// Test catch with exception values pushed to stack.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (type (func (param i32)))
+       (type (func (param i64)))
+       (tag $exn (type 0))
+       (tag $foo (type 1))
+       (tag $bar (type 2))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (i32.const 42)
+           (throw $exn)
+         catch $exn
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Throw an exception carrying more than one value.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32 i64 f32 f64)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32 i64 f32 f64)
+           (i32.const 42)
+           (i64.const 84)
+           (f32.const 42.2)
+           (f64.const 84.4)
+           (throw $exn)
+         catch $exn
+         catch_all
+           (i32.const 99)
+           (i64.const 999)
+           (f32.const 99.9)
+           (f64.const 999.9)
+         end
+         drop drop drop))`
+  ).exports.f(),
+  42
+);
+
+// This should also work inside nested frames.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32 i64 f32 f64)))
+       (tag $exn (type 0))
+       (func $foo (param i32 i64 f32 f64) (result i32 i64 f32 f64)
+         (local.get 0)
+         (local.get 1)
+         (local.get 2)
+         (local.get 3)
+         (throw $exn))
+       (func (export "f") (result i32)
+         try $l (result i32 i64 f32 f64)
+           (i32.const 42)
+           (i64.const 84)
+           (f32.const 42.2)
+           (f64.const 84.4)
+           (call $foo)
+         catch $exn
+         catch_all
+           (i32.const 99)
+           (i64.const 999)
+           (f32.const 99.9)
+           (f64.const 999.9)
+         end
+         drop drop drop))`
+  ).exports.f(),
+  42
+);
+
+// Multiple tagged catch in succession.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           (i32.const 42)
+           (throw $exn2)
+         catch $exn1
+         catch $exn2
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn0)
+       (tag $exn1)
+       (tag $exn2)
+       (tag $exn3)
+       (tag $exn4)
+       (tag $exn5)
+       (func (export "f") (result i32)
+         (try (result i32)
+           (do (throw $exn4))
+           (catch $exn5 (i32.const 5))
+           (catch $exn2 (i32.const 2))
+           (catch $exn4 (i32.const 4)) ;; Caught here.
+           (catch $exn4 (i32.const 44)))))`
+  ).exports.f(),
+  4
+);
+
+// Try catch with block parameters.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         (i32.const 42)
+         try (param i32) (result i32)
+           nop
+         catch $exn
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         (i32.const 42)
+         try $l (param i32) (result i32)
+           (throw $exn)
+         catch $exn
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Test the catch_all case.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try $l (result i32)
+           (i32.const 42)
+           (throw $exn2)
+         catch $exn1
+         catch_all
+           (i32.const 99)
+         end))`
+  ).exports.f(),
+  99
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             (i32.const 42)
+             (throw $exn)
+           catch_all
+             (i32.const 99)
+           end
+         catch $exn
+         end))`
+  ).exports.f(),
+  99
+);
+
+// Test foreign exception catch.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (import "m" "foreign" (func $foreign))
+       (tag $exn (type 0))
+       (func (export "f") (result i32) (local i32)
+         try $l
+           (call $foreign)
+         catch $exn
+         catch_all
+           (local.set 0 (i32.const 42))
+         end
+         (local.get 0)))`,
+    {
+      m: {
+        foreign() {
+          throw 5;
+        },
+      },
+    }
+  ).exports.f(),
+  42
+);
+
+// Exception handlers should not catch traps.
+assertErrorMessage(
+  () =>
+    wasmEvalText(
+      `(module
+         (type (func))
+         (tag $exn (type 0))
+         (func (export "f") (result i32) (local i32)
+           try $l
+             unreachable
+           catch $exn
+             (local.set 0 (i32.const 98))
+           catch_all
+             (local.set 0 (i32.const 99))
+           end
+           (local.get 0)))`
+    ).exports.f(),
+  WebAssembly.RuntimeError,
+  "unreachable executed"
+);
+
+// Ensure that a RuntimeError created by the user is not filtered out
+// as a trap emitted by the runtime (i.e., the filtering predicate is not
+// observable from JS).
+assertEq(
+  wasmEvalText(
+    `(module
+       (import "m" "foreign" (func $foreign))
+       (func (export "f") (result i32)
+         try (result i32)
+           (call $foreign)
+           (i32.const 99)
+         catch_all
+           (i32.const 42)
+         end))`,
+    {
+      m: {
+        foreign() {
+          throw new WebAssembly.RuntimeError();
+        },
+      },
+    }
+  ).exports.f(),
+  42
+);
+
+// Test uncatchable JS exceptions (OOM & stack overflow).
+{
+  let f = wasmEvalText(
+    `(module
+       (import "m" "foreign" (func $foreign))
+       (func (export "f") (result)
+         try
+           (call $foreign)
+         catch_all
+         end))`,
+    {
+      m: {
+        foreign() {
+          throwOutOfMemory();
+        },
+      },
+    }
+  ).exports.f;
+
+  var thrownVal;
+  try {
+    f();
+  } catch (exn) {
+    thrownVal = exn;
+  }
+
+  assertEq(thrownVal, "out of memory");
+}
+
+assertErrorMessage(
+  () =>
+    wasmEvalText(
+      `(module
+       (import "m" "foreign" (func $foreign))
+       (func (export "f")
+         try
+           (call $foreign)
+         catch_all
+         end))`,
+      {
+        m: {
+          foreign: function foreign() {
+            foreign();
+          },
+        },
+      }
+    ).exports.f(),
+  Error,
+  "too much recursion"
+);
+
+// Test all implemented instructions in a single module.
+{
+  let divFunctypeInline =
+      `(param $numerator i32) (param $denominator i32) (result i32)`;
+
+  let safediv = wasmEvalText(
+    `(module
+       (tag $divexn (param i32 i32))
+       (tag $notThrownExn (param i32))
+       (func $throwingdiv ${divFunctypeInline}
+          (local.get $numerator)
+          (local.get $denominator)
+          (if (param i32 i32) (result i32)
+            (i32.eqz (local.get $denominator))
+            (then
+              (try (param i32 i32)
+                (do (throw $divexn))
+                (delegate 0))
+              (i32.const 9))
+            (else
+              i32.div_u)))
+       (func $safediv (export "safediv") ${divFunctypeInline}
+          (local.get $numerator)
+          (local.get $denominator)
+          (try (param i32 i32) (result i32)
+            (do
+              (call $throwingdiv))
+            (catch $notThrownExn)
+            (catch $divexn
+              i32.add)
+            (catch_all
+              (i32.const 44)))))`
+  ).exports.safediv;
+
+  assertEq(safediv(6, 3), 2);
+  assertEq(safediv(6, 0), 6);
+}
+
+// Test simple rethrow.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch $exn
+             rethrow 0
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch_all
+             rethrow 0
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+// Test rethrows in nested blocks.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch $exn
+             block
+               rethrow 1
+             end
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch_all
+             block
+               rethrow 1
+             end
+           end
+           i32.const 1
+         catch $exn
+           i32.const 27
+         end))`
+  ).exports.f(),
+  27
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn1
+           catch $exn1
+             try
+               throw $exn2
+             catch $exn2
+               rethrow 1
+             end
+           end
+           i32.const 0
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         end))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn1 (type 0))
+       (tag $exn2 (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn1
+           catch $exn1
+             try
+               throw $exn2
+             catch_all
+               rethrow 1
+             end
+           end
+           i32.const 0
+         catch $exn1
+           i32.const 1
+         catch $exn2
+           i32.const 2
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Test that rethrow makes the rest of the block dead code.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag (param i32))
+       (func (export "f") (result i32)
+         (try (result i32)
+           (do (i32.const 1))
+           (catch 0
+             (rethrow 0)
+             (i32.const 2)))))`
+  ).exports.f(),
+  1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag (param i32))
+       (func (export "f") (result i32)
+         (try (result i32)
+           (do (try
+                 (do (i32.const 13)
+                     (throw 0))
+                 (catch 0
+                   (rethrow 0)))
+               (unreachable))
+           (catch 0))))`
+  ).exports.f(),
+  13
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag)
+       (func (export "f") (result i32)
+         (try (result i32)
+           (do
+             (try
+               (do (throw 0))
+               (catch 0
+                 (i32.const 4)
+                 (rethrow 0)))
+             (unreachable))
+           (catch 0
+              (i32.const 13)))))`
+  ).exports.f(),
+  13
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag (param i32))
+       (func (export "f") (result i32)
+         (try (result i32)
+           (do (try
+                 (do (i32.const 13)
+                     (throw 0))
+                 (catch 0
+                   (i32.const 111)
+                   (rethrow 0)))
+               (i32.const 222))
+           (catch 0))))`
+  ).exports.f(),
+  13
+);
+
+// Test try-delegate blocks.
+
+// Dead delegate to caller
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         i32.const 1
+         br 0
+         try
+           throw $exn
+         delegate 0))`
+  ).exports.f(),
+  1
+);
+
+// Nested try-delegate.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             try
+               throw $exn
+             delegate 0
+           end
+           i32.const 0
+         catch $exn
+           i32.const 1
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Non-throwing and breaking try-delegate.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 1
+           br 0
+         delegate 0))`
+    ).exports.f(),
+    1
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 1
+           return
+         delegate 0))`
+    ).exports.f(),
+    1
+  );
+
+// More nested try-delegate.
+assertEq(
+    wasmEvalText(
+      `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             i32.const 42
+             throw $exn
+           delegate 0
+           i32.const 0
+         catch $exn
+           i32.const 1
+           i32.add
+         end))`
+  ).exports.f(),
+  43
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try
+               i32.const 42
+               throw $exn
+             delegate 1
+             i32.const 0
+           catch $exn
+             i32.const 1
+             i32.add
+           end
+         catch $exn
+           i32.const 2
+           i32.add
+         end))`
+  ).exports.f(),
+  44
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           try (result i32)
+             try (result i32)
+               try
+                 i32.const 42
+                 throw $exn
+               delegate 1
+               i32.const 0
+             catch $exn
+               i32.const 1
+               i32.add
+             end
+           delegate 0
+         catch $exn
+           i32.const 2
+           i32.add
+         end))`
+  ).exports.f(),
+  44
+);
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func $g (param i32) (result i32) (i32.const 42))
+       (func (export "f") (result i32)
+         try (result i32)
+           try $t
+             block (result i32)
+               (i32.const 4)
+               (call $g)
+               try
+                 throw $exn
+               delegate $t
+             end
+             drop
+           end
+           i32.const 0
+         catch_all
+           i32.const 1
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Test delegation to function body and blocks.
+
+// Non-throwing.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 1
+         delegate 0))`
+  ).exports.f(),
+  1
+);
+
+// Block target.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param i32))
+       (func (export "f") (result i32)
+         try (result i32)
+           block
+             try
+               i32.const 1
+               throw $exn
+             delegate 0
+           end
+           i32.const 0
+         catch $exn
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Catch target.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           try
+             throw $exn
+           catch $exn
+             try
+               throw $exn
+             delegate 0
+           end
+           i32.const 0
+         catch_all
+           i32.const 1
+         end))`
+  ).exports.f(),
+  1
+);
+
+// Target function body.
+assertEq(
+  wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (func (export "f") (result i32)
+         try (result i32)
+           call $g
+         catch $exn
+         end)
+       (func $g (result i32)
+         try (result i32)
+           try
+             i32.const 42
+             throw $exn
+           delegate 1
+           i32.const 0
+         catch $exn
+           i32.const 1
+           i32.add
+         end))`
+  ).exports.f(),
+  42
+);
+
+// Try-delegate from inside a loop.
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn)
+       ;; For the purpose of this test, the params below should be increasing.
+       (func (export "f") (param $depth_to_throw_exn i32)
+                          (param $maximum_loop_iterations i32)
+                          (result i32)
+                          (local $loop_countdown i32)
+                          ;; Counts how many times the loop was started.
+                          (local $loop_verifier i32)
+         ;; The loop is counting down.
+         (local.get $maximum_loop_iterations)
+         (local.set $loop_countdown)
+         (try $catch_exn (result i32)
+           (do
+             (try
+               (do
+                 (loop $loop
+                   ;; Counts how many times the loop was started.
+                   (local.set $loop_verifier
+                              (i32.add (i32.const 1)
+                                       (local.get $loop_verifier)))
+                   (if (i32.eqz (local.get $loop_countdown))
+                     (then (return (i32.const 440)))
+                     (else
+                       (try $rethrow_label
+                         (do
+                           (if (i32.eq (local.get $depth_to_throw_exn)
+                                       (local.get $loop_countdown))
+                               (then (throw $exn))
+                               (else
+                                 (local.set $loop_countdown
+                                            (i32.sub (local.get $loop_countdown)
+                                                     (i32.const 1))))))
+                         (catch $exn (try
+                                       (do (rethrow $rethrow_label))
+                                       (delegate $catch_exn))))))
+                   (br $loop)))
+               (catch_all unreachable))
+             (i32.const 2000))
+           (catch_all (i32.const 10000)))
+         (i32.add (local.get $loop_verifier))))`
+  ).exports.f(3, 5),
+  10003
+);
diff --git a/js/src/jit-test/tests/wasm/exceptions/ion-loop-phi.js b/js/src/jit-test/tests/wasm/exceptions/ion-loop-phi.js
new file mode 100644
index 0000000000..bdf49ca97b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/ion-loop-phi.js
@@ -0,0 +1,59 @@
+// Finishing a loop will try to minimize phi nodes. We must properly replace
+// phi nodes that escape a loop via catch block control flow patches.
+wasmEvalText(`(module
+  (func)
+  (func (local i32)
+    try
+      loop
+        call 0
+        i32.const 0
+        br_if 0
+      end
+    catch_all
+    end
+  )
+)`);
+
+// Same as above, but ensure that we check every enclosing try block for
+// control flow patches, as delegate can tunnel outwards.
+wasmEvalText(`(module
+  (func)
+  (func (local i32)
+    try
+      try
+        loop
+          call 0
+          i32.const 0
+          br_if 0
+        end
+      delegate 0
+    catch_all
+    end
+  )
+)`);
+
+// Ensure that we check the body block as delegate can target that.
+wasmEvalText(`(module
+  (func)
+  (func (local i32)
+    loop
+      try
+        (; catch patch to try block is added ;)
+        call 0
+        (; br_if ensures we will need a backedge ;)
+        i32.const 0
+        br_if 1
+      (; catch patches are relocated to body ;)
+      delegate 1
+    (; finishing loop backedge must fixup patches stored in body ;)
+    end
+
+    (; add another catch patch to body so that the landing pad will be a
+       join point between two edges, forcing a use of the dangling phi,
+       hitting the debug assertion
+    ;)
+    try
+      call 0
+    delegate 0
+  )
+)`);
diff --git a/js/src/jit-test/tests/wasm/exceptions/js-api.js b/js/src/jit-test/tests/wasm/exceptions/js-api.js
new file mode 100644
index 0000000000..4c2f018808
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/js-api.js
@@ -0,0 +1,490 @@
+// Tests for wasm exception proposal JS API features.
+
+load(libdir + "eqArrayHelper.js");
+
+// WebAssembly.Tag tests.
+assertErrorMessage(
+  () => WebAssembly.Tag(),
+  TypeError,
+  /calling a builtin Tag constructor without new is forbidden/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Tag(),
+  TypeError,
+  /At least 1 argument required/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Tag(3),
+  TypeError,
+  /first argument must be a tag descriptor/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Tag({ parameters: ["foobar"] }),
+  TypeError,
+  /bad value type/
+);
+
+new WebAssembly.Tag({ parameters: [] });
+new WebAssembly.Tag({ parameters: ["i32"] });
+new WebAssembly.Tag({ parameters: ["i32", "externref"] });
+
+wasmEvalText(`(module (import "m" "e" (tag)))`, {
+  m: { e: new WebAssembly.Tag({ parameters: [] }) },
+});
+
+wasmEvalText(`(module (import "m" "e" (tag (param i32))))`, {
+  m: { e: new WebAssembly.Tag({ parameters: ["i32"] }) },
+});
+
+wasmEvalText(`(module (import "m" "e" (tag (param i32 i64))))`, {
+  m: { e: new WebAssembly.Tag({ parameters: ["i32", "i64"] }) },
+});
+
+assertErrorMessage(
+  () =>
+    wasmEvalText(`(module (import "m" "e" (tag (param i32))))`, {
+      m: { e: new WebAssembly.Tag({ parameters: [] }) },
+    }),
+  WebAssembly.LinkError,
+  /imported tag 'm.e' signature mismatch/
+);
+
+assertErrorMessage(
+  () =>
+    wasmEvalText(`(module (import "m" "e" (tag (param))))`, {
+      m: { e: new WebAssembly.Tag({ parameters: ["i32"] }) },
+    }),
+  WebAssembly.LinkError,
+  /imported tag 'm.e' signature mismatch/
+);
+
+// Test WebAssembly.Tag methods.
+// TODO: add runtime detection for js-types
+// {
+//   let params = [
+//     [],
+//     ["i32"],
+//     ["i32", "i64"],
+//     ["f32", "externref"],
+//     ["i32", "i64", "f32", "f64"],
+//   ];
+
+//   for (const arg of params) {
+//     const tag = new WebAssembly.Tag({ parameters: arg });
+//     assertEqArray(tag.type().parameters, arg);
+//   }
+// }
+
+// WebAssembly.Exception tests.
+assertErrorMessage(
+  () => WebAssembly.Exception(),
+  TypeError,
+  /calling a builtin Exception constructor without new is forbidden/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(),
+  TypeError,
+  /At least 2 arguments required/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(3, []),
+  TypeError,
+  /first argument must be a WebAssembly.Tag/
+);
+
+const { tag1, tag2, tag3, tag4, tag5, tag6, tag7, tag8, tag9 } = wasmEvalText(
+  `(module
+     (tag (export "tag1") (param))
+     (tag (export "tag2") (param i32))
+     (tag (export "tag3") (param i32 f32))
+     (tag (export "tag4") (param i32 externref i32))
+     (tag (export "tag5") (param i32 externref i32 externref))
+     (tag (export "tag6") (param funcref))
+     (tag (export "tag7") (param i64))
+     (tag (export "tag8") (param i32 f64))
+     (tag (export "tag9") (param externref funcref)))`
+).exports;
+
+new WebAssembly.Exception(tag1, []);
+new WebAssembly.Exception(tag2, [3]);
+new WebAssembly.Exception(tag3, [3, 5.5]);
+new WebAssembly.Exception(tag4, [3, "foo", 4]);
+new WebAssembly.Exception(tag5, [3, "foo", 4, "bar"]);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(tag2, []),
+  TypeError,
+  /expected 1 values but got 0/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(tag2, [3n]),
+  TypeError,
+  /can't convert BigInt to number/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(tag6, [undefined]),
+  TypeError,
+  /can only pass WebAssembly exported functions to funcref/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(tag7, [undefined]),
+  TypeError,
+  /can't convert undefined to BigInt/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(tag7, {}),
+  TypeError,
+  /\({}\) is not iterable/
+);
+
+assertErrorMessage(
+  () => new WebAssembly.Exception(tag7, 1),
+  TypeError,
+  /second argument must be an object/
+);
+
+// Test Exception methods.
+{
+  const exn1 = new WebAssembly.Exception(tag1, []);
+  assertEq(exn1.is(tag1), true);
+  assertEq(exn1.is(tag2), false);
+  assertErrorMessage(
+    () => exn1.is(),
+    TypeError,
+    /At least 1 argument required/
+  );
+  assertErrorMessage(
+    () => exn1.is(5),
+    TypeError,
+    /first argument must be a WebAssembly.Tag/
+  );
+
+  const exn2 = new WebAssembly.Exception(tag2, [3]);
+  assertEq(exn2.getArg(tag2, 0), 3);
+
+  assertEq(new WebAssembly.Exception(tag2, [undefined]).getArg(tag2, 0), 0);
+
+  const exn4 = new WebAssembly.Exception(tag4, [3, "foo", 4]);
+  assertEq(exn4.getArg(tag4, 0), 3);
+  assertEq(exn4.getArg(tag4, 1), "foo");
+  assertEq(exn4.getArg(tag4, 2), 4);
+
+  const exn5 = new WebAssembly.Exception(tag5, [3, "foo", 4, "bar"]);
+  assertEq(exn5.getArg(tag5, 3), "bar");
+
+  const { funcref } = wasmEvalText(
+    `(module (func (export "funcref")))`
+  ).exports;
+  const exn9 = new WebAssembly.Exception(tag9, ["foo", funcref]);
+  assertEq(exn9.getArg(tag9, 0), "foo");
+  assertEq(exn9.getArg(tag9, 1), funcref);
+
+  assertErrorMessage(
+    () => exn2.getArg(),
+    TypeError,
+    /At least 2 arguments required/
+  );
+  assertErrorMessage(
+    () => exn2.getArg(5, 0),
+    TypeError,
+    /first argument must be a WebAssembly.Tag/
+  );
+  assertErrorMessage(
+    () => exn2.getArg(tag2, "foo"),
+    TypeError,
+    /bad Exception getArg index/
+  );
+  assertErrorMessage(
+    () => exn2.getArg(tag2, 10),
+    RangeError,
+    /bad Exception getArg index/
+  );
+}
+
+// Test throwing a JS constructed exception to Wasm.
+assertEq(
+  wasmEvalText(
+    `(module
+       (import "m" "exn" (tag $exn (param i32)))
+       (import "m" "f" (func $f))
+       (func (export "f") (result i32)
+         try (result i32)
+           call $f
+           (i32.const 0)
+         catch $exn
+         end))`,
+    {
+      m: {
+        exn: tag2,
+        f: () => {
+          throw new WebAssembly.Exception(tag2, [42]);
+        },
+      },
+    }
+  ).exports.f(),
+  42
+);
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (import "m" "exn" (tag $exn (param i32 f32)))
+       (import "m" "f" (func $f))
+       (func (export "f") (result i32 f32)
+         try (result i32 f32)
+           call $f
+           (i32.const 0)
+           (f32.const 0)
+         catch $exn
+         end))`,
+    {
+      m: {
+        exn: tag3,
+        f: () => {
+          throw new WebAssembly.Exception(tag3, [42, 5.5]);
+        },
+      },
+    }
+  ).exports.f(),
+  [42, 5.5]
+);
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (import "m" "exn" (tag $exn (param i32 f64)))
+       (import "m" "f" (func $f))
+       (func (export "f") (result i32 f64)
+         try (result i32 f64)
+           call $f
+           (i32.const 0)
+           (f64.const 0)
+         catch $exn
+         end))`,
+    {
+      m: {
+        exn: tag8,
+        f: () => {
+          throw new WebAssembly.Exception(tag8, [9999, 9999]);
+        },
+      },
+    }
+  ).exports.f(),
+  [9999, 9999]
+);
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (import "m" "exn" (tag $exn (param i32 externref i32)))
+       (import "m" "f" (func $f))
+       (func (export "f") (result i32 externref i32)
+         try (result i32 externref i32)
+           call $f
+           (i32.const 0)
+           (ref.null extern)
+           (i32.const 0)
+         catch $exn
+         end))`,
+    {
+      m: {
+        exn: tag4,
+        f: () => {
+          throw new WebAssembly.Exception(tag4, [42, "foo", 42]);
+        },
+      },
+    }
+  ).exports.f(),
+  [42, "foo", 42]
+);
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (import "m" "exn" (tag $exn (param i32 externref i32 externref)))
+       (import "m" "f" (func $f))
+       (func (export "f") (result i32 externref i32 externref)
+         try (result i32 externref i32 externref)
+           call $f
+           (i32.const 0)
+           (ref.null extern)
+           (i32.const 0)
+           (ref.null extern)
+         catch $exn
+         end))`,
+    {
+      m: {
+        exn: tag5,
+        f: () => {
+          throw new WebAssembly.Exception(tag5, [42, "foo", 42, "bar"]);
+        },
+      },
+    }
+  ).exports.f(),
+  [42, "foo", 42, "bar"]
+);
+
+{
+  const { funcref } = wasmEvalText(
+    `(module (func (export "funcref")))`
+  ).exports;
+  assertEqArray(
+    wasmEvalText(
+      `(module
+         (import "m" "exn" (tag $exn (param externref funcref)))
+         (import "m" "f" (func $f))
+         (func (export "f") (result externref funcref)
+           try (result externref funcref)
+             call $f
+             (ref.null extern)
+             (ref.null func)
+           catch $exn
+           end))`,
+      {
+        m: {
+          exn: tag9,
+          f: () => {
+            throw new WebAssembly.Exception(tag9, ["foo", funcref]);
+          },
+        },
+      }
+    ).exports.f(),
+    ["foo", funcref]
+  );
+}
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (import "m" "exn" (tag $exn))
+       (import "m" "f" (func $f))
+       (func (export "f") (result i32)
+         try (result i32)
+           call $f
+           (i32.const 0)
+         catch $exn
+           (i32.const 0)
+         catch_all
+           (i32.const 1)
+         end))`,
+    {
+      m: {
+        exn: tag1,
+        f: () => {
+          throw new WebAssembly.Exception(tag2, [42]);
+        },
+      },
+    }
+  ).exports.f(),
+  1
+);
+
+{
+  const exn = new WebAssembly.Tag({ parameters: ["i32"] });
+  assertEq(
+    wasmEvalText(
+      `(module
+         (import "m" "exn" (tag $exn (param i32)))
+         (import "m" "f" (func $f))
+         (func (export "f") (result i32)
+           try (result i32)
+             call $f
+             (i32.const 0)
+           catch $exn
+           end))`,
+      {
+        m: {
+          exn,
+          f: () => {
+            throw new WebAssembly.Exception(exn, [42]);
+          },
+        },
+      }
+    ).exports.f(),
+    42
+  );
+}
+
+{
+  const exn1 = new WebAssembly.Tag({ parameters: ["i32"] });
+  const exn2 = new WebAssembly.Tag({ parameters: ["i32"] });
+  assertEq(
+    wasmEvalText(
+      `(module
+         (import "m" "exn" (tag $exn (param i32)))
+         (import "m" "f" (func $f))
+         (func (export "f") (result i32)
+           try (result i32)
+             call $f
+             (i32.const 0)
+           catch $exn
+           catch_all
+             (i32.const 1)
+           end))`,
+      {
+        m: {
+          exn: exn1,
+          f: () => {
+            throw new WebAssembly.Exception(exn2, [42]);
+          },
+        },
+      }
+    ).exports.f(),
+    1
+  );
+}
+
+// Test `getArg` on a Wasm-thrown exception.
+assertEq(
+  (() => {
+    try {
+      wasmEvalText(
+        `(module
+           (import "m" "exn" (tag $exn (param i32 f64)))
+           (func (export "f")
+             (i32.const 9999)
+             (f64.const 9999)
+             throw $exn))`,
+        { m: { exn: tag8 } }
+      ).exports.f();
+    } catch (exn) {
+      return exn.getArg(tag8, 1);
+    }
+  })(),
+  9999
+);
+
+assertEqArray(
+  (() => {
+    try {
+      wasmEvalText(
+        `(module
+           (import "m" "exn" (tag $exn (param i32 externref i32 externref)))
+           (func (export "f") (param externref externref)
+             (i32.const 1)
+             (local.get 0)
+             (i32.const 2)
+             (local.get 1)
+             throw $exn))`,
+        { m: { exn: tag5 } }
+      ).exports.f("foo", "bar");
+    } catch (exn) {
+      return [
+        exn.getArg(tag5, 0),
+        exn.getArg(tag5, 1),
+        exn.getArg(tag5, 2),
+        exn.getArg(tag5, 3),
+      ];
+    }
+  })(),
+  [1, "foo", 2, "bar"]
+);
diff --git a/js/src/jit-test/tests/wasm/exceptions/memory.js b/js/src/jit-test/tests/wasm/exceptions/memory.js
new file mode 100644
index 0000000000..fef249ddf5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/memory.js
@@ -0,0 +1,78 @@
+// Ensure memory operations work after a throw coming from a function call.
+// These are also testing that the InstanceReg/HeapReg are set correctly after
+// catching an exception. There are some variations to the kind of calls here;
+// we test for direct/indirect calls of local/imported functions, and the
+// indirect calls may come from a local table or an imported table.
+
+// Throw from a direct/indirect call of a local/imported function.
+{
+  let exports = wasmEvalText(
+    `(module $m
+       (memory $mem (data "bar"))
+       (tag $exn (export "exn"))
+       (tag $dummyExn (export "dummyExn"))
+       (func $throwsExn (export "throwsExn")
+         (throw $exn))
+       (func $anotherThrowsExn
+         (throw $exn))
+       (func $throwsDummyExn (export "throwsDummyExn")
+         (throw $dummyExn))
+       (table (export "tab") funcref (elem $anotherThrowsExn $throwsDummyExn)))`
+  ).exports;
+
+  function testMemoryAfterCall(callInstruction) {
+    assertEq(
+      wasmEvalText(
+        `(module
+           (import "m" "exn" (tag $exn))
+           (tag $localExn (param i32))
+           (type $t (func))
+           (import "m" "tab" (table $importTable 2 funcref))
+           (import "m" "throwsExn" (func $importFuncThrowsExn))
+           (memory $mem (data "foo"))
+           (func $localFuncThrowsExn
+             (throw $exn))
+           (table $localTable funcref
+                  (elem $localFuncThrowsExn $importFuncThrowsExn))
+           (func $anotherLocalFuncThrowsExn
+             (throw $exn))
+           (func $throwsLocalExn
+             (throw $localExn
+               (i32.const 9)))
+           (func (export "testFunc") (result i32)
+             (try (result i32)
+               (do
+                 ${callInstruction}
+                 ;; All the rest should not be reachable.
+                 (call $anotherLocalFuncThrowsExn)
+                 (throw $exn)
+                 (call $throwsLocalExn)
+                 unreachable)
+               (catch $localExn)
+               (catch $exn
+                 (i32.load8_u
+                   (i32.const 0)))
+               (catch $exn
+                 ;; This should be ignored.
+                 unreachable))))`,
+        { m: exports }
+      ).exports.testFunc(),
+      'foo'.charCodeAt(0)
+    );
+  };
+
+  // Run test for various calls.
+  let callInstructions =
+      ["(call $anotherLocalFuncThrowsExn)",
+       "(call $importFuncThrowsExn)",
+       // Calls $localFuncThrowsExn.
+       "(call_indirect $localTable (type $t) (i32.const 0))",
+       // Calls $importFuncThrowsExn.
+       "(call_indirect $localTable (type $t) (i32.const 1))",
+       // Calls non exported function of the exports module $anotherThrowsExn.
+       "(call_indirect $importTable (type $t) (i32.const 0))"];
+
+  for (let callInstruction of callInstructions) {
+    testMemoryAfterCall(callInstruction);
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/exceptions/prototypes.js b/js/src/jit-test/tests/wasm/exceptions/prototypes.js
new file mode 100644
index 0000000000..757ed2ddba
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/prototypes.js
@@ -0,0 +1,10 @@
+class _Tag extends WebAssembly.Tag {}
+class _Exception extends WebAssembly.Exception {}
+
+let tag = new _Tag({parameters: []});
+assertEq(tag instanceof _Tag, true);
+assertEq(tag instanceof WebAssembly.Tag, true);
+
+let exception = new _Exception(tag, []);
+assertEq(exception instanceof _Exception, true);
+assertEq(exception instanceof WebAssembly.Exception, true);
diff --git a/js/src/jit-test/tests/wasm/exceptions/reftypes.js b/js/src/jit-test/tests/wasm/exceptions/reftypes.js
new file mode 100644
index 0000000000..efd577dec8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/reftypes.js
@@ -0,0 +1,141 @@
+// Exception tests that use reference types.
+
+load(libdir + "eqArrayHelper.js");
+
+assertEq(
+  wasmEvalText(
+    `(module
+       (tag $exn (param externref))
+       (func (export "f") (result externref)
+         try (result externref)
+           ref.null extern
+           throw $exn
+         catch $exn
+         end))`
+  ).exports.f(),
+  null
+);
+
+{
+  let f = wasmEvalText(
+    `(module
+       (tag $exn (param funcref))
+       (func $f (export "f") (result funcref)
+         try (result funcref)
+           ref.func $f
+           throw $exn
+         catch $exn
+         end))`
+  ).exports.f;
+  assertEq(f(), f);
+}
+
+{
+  let f = wasmEvalText(
+    `(module
+       (tag $exn (param externref))
+       (func (export "f") (param externref) (result externref)
+         try (result externref)
+           local.get 0
+           throw $exn
+         catch $exn
+         end))`
+  ).exports.f;
+
+  for (v of WasmExternrefValues) {
+    assertEq(f(v), v);
+  }
+}
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (tag $exn (param externref externref))
+       (func (export "f") (param externref externref)
+             (result externref externref)
+         try (result externref externref)
+           local.get 0
+           local.get 1
+           throw $exn
+         catch $exn
+         end))`
+  ).exports.f("foo", "bar"),
+  ["foo", "bar"]
+);
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (tag $exn (param i32 i32 externref f32))
+       (func (export "f") (param externref)
+             (result i32 i32 externref f32)
+         try (result i32 i32 externref f32)
+           i32.const 0
+           i32.const 1
+           local.get 0
+           f32.const 2.0
+           throw $exn
+         catch $exn
+         end))`
+  ).exports.f("foo"),
+  [0, 1, "foo", 2.0]
+);
+
+assertEqArray(
+  wasmEvalText(
+    `(module
+       (tag $exn (param i32 i32 externref f32 externref f64))
+       (func (export "f") (param externref externref)
+             (result i32 i32 externref f32 externref f64)
+         try (result i32 i32 externref f32 externref f64)
+           i32.const 0
+           i32.const 1
+           local.get 0
+           f32.const 2.0
+           local.get 1
+           f64.const 3.0
+           throw $exn
+         catch $exn
+         end))`
+  ).exports.f("foo", "bar"),
+  [0, 1, "foo", 2.0, "bar", 3.0]
+);
+
+// Test to ensure that reference typed values are tracked correctly by
+// the GC within exception objects.
+{
+  gczeal(2, 1); // Collect on every allocation.
+
+  var thrower;
+  let exports = wasmEvalText(
+    `(module
+       (tag $exn (param externref))
+       (import "m" "f" (func $f (result externref)))
+       (func (export "thrower") (param externref)
+         (local.get 0)
+         (throw $exn))
+       (func (export "catcher") (result externref)
+         try (result externref)
+           (call $f)
+         catch $exn
+         end))`,
+    {
+      m: {
+        f: () => {
+          // The purpose of this intermediate try-catch in JS is to force
+          // some allocation to occur after Wasm's `throw`, triggering GC, and
+          // then rethrow back to Wasm to observe any errors.
+          try {
+            thrower("foo");
+          } catch (e) {
+            let v = { x: 5 };
+            throw e;
+          }
+        },
+      },
+    }
+  ).exports;
+
+  thrower = exports.thrower;
+  assertEq(exports.catcher(), "foo");
+}
diff --git a/js/src/jit-test/tests/wasm/exceptions/side-effects-in-try.js b/js/src/jit-test/tests/wasm/exceptions/side-effects-in-try.js
new file mode 100644
index 0000000000..d5d5567fca
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/side-effects-in-try.js
@@ -0,0 +1,234 @@
+// -----------------------------------------------------------------------------
+// The tests in this file assert that any side effects that happened in try code
+// before an exception was thrown, will be known to the landing pad. It checks
+// local throws and throws from direct calls (of local and imported functions).
+// Side effects checked are changes to locals, and to globals.
+// -----------------------------------------------------------------------------
+
+load(libdir + "eqArrayHelper.js");
+
+
+function testSideEffectsOnLocals() {
+  // Locals set before and after throwing instructions, either locally, or from
+  // a direct wasm function call, for locals of all Wasm numtype and a local of
+  // reftype (externref), and the thrown exception carrying a value from each
+  // Wasm numtype and one of Wasm vectype (Simd128). Testing to see if the state
+  // of the locals at the moment $exn is thrown, is known to the landing pad
+  // when $exn is caught.
+
+  let localThrow = "(throw $exn)";
+
+  // The following is taken from calls.js
+  // Some variables to be used in all tests.
+  let typesJS = ["i32", "i64", "f32", "f64"];
+  let types = typesJS.join(" ");
+  let exnTypeDef = `(type $exnType (func (param ${types})))`;
+  let correctLocalValues =
+      `;; Correct local values
+             (i32.const 2)
+             (i64.const 3)
+             (f32.const 4)
+             (f64.const 13.37)`;
+  let correctLocalValuesJS = [2, 3n, 4, 13.37];
+
+  let wrongValues =
+      `;; Wrong values.
+             (i32.const 5)
+             (i64.const 6)
+             (f32.const 0.1)
+             (f64.const 0.6437)`;
+  let wrongValuesJS = [5, 6n, 0.1, 0.6437];
+
+  // These variables are specific to the tests in this file.
+  let throwValues =
+      `;; Values to throw and catch.
+             (i32.const 7)
+             (i64.const 8)
+             (f32.const 9)
+             (f64.const 27.11)`;
+  let thrownValuesJS = [7, 8n, 9, 27.11];
+
+  let correctResultsJS = function(externref) {
+    return [].concat(thrownValuesJS,
+                     correctLocalValuesJS,
+                     [externref, 1]);
+  }
+
+  // Testing also locals of Wasm vectype.
+  // The following depend on whether simd is enabled or not. We write it like
+  // this so we can run this test also when SIMD is not enabled.
+  let wrongV128 = "";
+  let correctV128 = "";
+  let checkV128Value = "";
+
+  if (wasmSimdEnabled()) {
+    wrongV128 = `(v128.const i32x4 11 22 33 44)`;
+    correctV128 = `(v128.const i32x4 55 66 77 88)`;
+    checkV128Value =
+      `       ${correctV128}
+              (i32x4.eq)
+              (i32x4.all_true)`;
+    v128Type = " v128";
+  } else {
+    wrongV128 = "(i32.const 0)";
+    correctV128 = "(i32.const 1)";
+    v128Type = " i32";
+  }
+
+  let localTypes = types + " externref";
+  let resultTypes = types + " " + localTypes;
+
+  // The last i32 in the results is the v128 check.
+  let testFuncTypeInline =
+      `(param $argCorrectRef externref)
+       (param $argWrongRef externref)
+       (result ${resultTypes} i32)
+       (local $localI32 i32)
+       (local $localI64 i64)
+       (local $localF32 f32)
+       (local $localF64 f64)
+       (local $localExternref externref)
+       (local $localV128 ${v128Type})`;
+
+  let localsSet =
+      `;; Set locals.
+             (local.set $localV128)
+             (local.set $localExternref)
+             (local.set $localF64)
+             (local.set $localF32)
+             (local.set $localI64)
+             (local.set $localI32)`;
+  let localsGet =
+      `;; Get locals.
+             (local.get $localI32)
+             (local.get $localI64)
+             (local.get $localF32)
+             (local.get $localF64)
+             (local.get $localExternref)
+             (local.get $localV128)`;
+
+  // The test module parts. ----------------------------------------------------
+
+  let importsModule =
+      `(module
+         (type $exnType (func (param ${types})))
+         (tag $exn (export "exn") (type $exnType))
+         (func (export "throwif") (param $ifPredicate i32)
+           (if (local.get $ifPredicate)
+             (then
+               ${throwValues}
+               ${localThrow}))))`;
+
+  let moduleHeader = `
+       (module
+         ${exnTypeDef}
+         (import "m" "exn" (tag $exn (type $exnType)))
+         (tag $emptyExn)
+         (import "m" "throwif" (func $throwif (param $ifPredicate i32)))
+         (func $wontThrow
+           (throw $emptyExn))
+         (func $localCallThrow
+             ${throwValues}
+             ${localThrow})
+         (func (export "testFunc") ${testFuncTypeInline}
+           (try (result ${resultTypes} ${v128Type})
+             (do
+               ;; Locals not set.
+               (i32.const 0) ;; Predicate for $throwif.
+               (call $throwif)  ;; So this doesn't throw.
+               ;; Set correct locals before throw to be caught.
+               ${correctLocalValues}
+               (local.get $argCorrectRef)
+               ${correctV128}
+               ${localsSet}
+               ;; Next up should be $exn being thrown locally or via a call.`;
+
+  let moduleRest = ` ;; The above throw to $exn should be caught here --------.
+               ;; Set wrong locals after throw to be caught.              ;;    |
+               ${wrongValues}                                             ;;    |
+               (local.get $argWrongRef) ;; The wrong externref param.     ;;    |
+               ${wrongV128}                                               ;;    |
+               ${localsSet}                                               ;;    |
+               (call $wontThrow)                                          ;;    |
+               ${wrongValues}                                             ;;    |
+               ${localsGet});; End of try code.                           ;;    |
+             (catch $emptyExn                                             ;;    |
+               ${wrongValues}                                             ;;    |
+               ${localsGet})                                              ;;    |
+             (catch $exn ;; <---------------------------------------------------'
+               ${localsGet})
+             (catch_all
+               ${wrongValues}
+               ${localsGet}))
+           ;; Check if the local has the correct v128 value.
+           ${checkV128Value}))`;
+
+  let localThrowValues = `
+             ${throwValues}
+             (throw $exn)`;
+  let directLocalCall = `
+             (call $localCallThrow)`;
+  let directImportCall = `
+             (i32.const 1)
+             (call $throwif)`;
+
+  // Run test for side effects on locals before throwing an exception locally,
+  // or from a direct call.
+
+  let callInstructions = [localThrowValues, directLocalCall, directImportCall];
+
+  for (let callThrow of callInstructions) {
+    console.log("callThrow = " + callThrow); // Uncomment for debugging.
+    moduleText = moduleHeader + callThrow + moduleRest;
+    console.log("moduleText = " + moduleText); // Uncomment for debugging.
+    assertEqArray(
+      wasmEvalText(moduleText,
+                   { m : wasmEvalText(importsModule).exports }
+                  ).exports.testFunc("foo", "wrongFoo"),
+      correctResultsJS("foo"));
+  }
+}
+
+// Setting globals in try code, and testing to see if the changes are known to
+// the landing pad.
+function testGlobals() {
+  let test = function (type, initialValue, resultValue, wrongValue, coercion) {
+    let exports = wasmEvalText(
+      `(module
+         (tag (export "exn"))
+         (func (export "throws")
+           (throw 0)))`
+    ).exports;
+
+    assertEq(
+      wasmEvalText(
+        `(module
+           (import "m" "exn" (tag $exn))
+           (tag $notThrownExn)
+           (import "m" "throws" (func $throws))
+           (global (mut ${type}) (${type}.const ${initialValue}))
+           (func (export "testFunc") (result ${type})
+             (try (result ${type})
+               (do
+                 (global.set 0 (${type}.const ${resultValue}))
+                 (call $throws)
+                 (global.set 0 (${type}.const ${wrongValue}))
+                 (global.get 0))
+               (catch $notThrownExn
+                 (${type}.const ${wrongValue}))
+               (catch $exn
+                 (global.get 0)))))`,
+        { m: exports }
+      ).exports.testFunc(), coercion(resultValue));
+  };
+
+  test("i32", 2, 7, 27, x => x);
+  test("i64", 2n, 7n, 27n, x => x);
+  test("f32", 0.3, 0.1, 0.6, Math.fround);
+  test("f64", 13.37, 0.6437244242412325666666, 4, x => x);
+};
+
+// Run all tests.
+
+testSideEffectsOnLocals();
+testGlobals();
diff --git a/js/src/jit-test/tests/wasm/exceptions/stack.js b/js/src/jit-test/tests/wasm/exceptions/stack.js
new file mode 100644
index 0000000000..337ecd54b8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/stack.js
@@ -0,0 +1,28 @@
+let tag = new WebAssembly.Tag({parameters: []});
+
+function construct(options) {
+	return new WebAssembly.Exception(tag, [], options);
+}
+function noStack(options) {
+	assertEq(construct(options).stack, undefined, 'no stack');
+}
+function hasStack(options) {
+	assertEq(typeof construct(options).stack === 'string', true, 'has stack');
+}
+
+// Test valid option constructors
+noStack(undefined);
+noStack(null);
+noStack({});
+noStack({traceStack: false});
+noStack({traceStack: 0});
+hasStack({traceStack: true});
+hasStack({traceStack: 1});
+
+// Test invalid option constructors
+assertErrorMessage(() => construct('not an object'), TypeError, /cannot be converted/);
+
+// Test that 'stack' is read-only
+let exception = construct({traceStack: true});
+exception.stack = 0;
+assertEq(typeof exception.stack === 'string', true, 'is read-only');
diff --git a/js/src/jit-test/tests/wasm/exceptions/throw-to-js.js b/js/src/jit-test/tests/wasm/exceptions/throw-to-js.js
new file mode 100644
index 0000000000..6ddc389cc1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/throw-to-js.js
@@ -0,0 +1,343 @@
+// Tests for throwing exceptions to JS from Wasm.
+
+function assertWasmThrowsExn(thunk) {
+  let thrown = false;
+
+  try {
+    thunk();
+  } catch (exn) {
+    thrown = true;
+    assertEq(exn instanceof WebAssembly.Exception, true);
+  }
+
+  assertEq(thrown, true, "missing exception");
+}
+
+// Test that handler-less trys don't catch anything.
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f")
+         try (throw $exn) end))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func $g (throw $exn))
+       (func (export "f")
+         try (call $g) end)
+)`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f")
+         try try (throw $exn) end end))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f")
+         try
+           try
+             throw $exn
+           delegate 0
+         end))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f")
+         try
+           try
+             throw $exn
+           delegate 1
+         end))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f")
+         block
+           try
+             throw $exn
+           delegate 0
+         end))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f")
+         loop
+           try
+             throw $exn
+           delegate 0
+         end))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f")
+         (i32.const 1)
+         if
+           try
+             throw $exn
+           delegate 0
+         end))`
+  ).exports.f()
+);
+
+// Test throwing simple empty exceptions to JS.
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (type (func (param)))
+       (tag $exn (type 0))
+       (func (export "f")
+         (throw $exn)))`
+  ).exports.f()
+);
+
+// Test that wasm preserves the values of non-object exceptions that pass
+// through it back to JS.
+assertThrowsValue(
+  () =>
+    wasmEvalText(
+      `(module
+         (tag $exn)
+         (import "m" "import" (func $import))
+         (func (export "f")
+           try
+             (call $import)
+           catch $exn
+             ;; this block shouldn't be reached
+           end))`,
+      {
+        m: {
+          import: () => {
+            throw 42;
+          },
+        },
+      }
+    ).exports.f(),
+  42
+);
+
+// Like previous test, but using a rethrow instruction instead.
+assertThrowsValue(
+  () =>
+    wasmEvalText(
+      `(module
+         (import "m" "import" (func $import))
+         (func (export "f")
+           try
+             (call $import)
+           catch_all
+             (rethrow 0)
+           end))`,
+      {
+        m: {
+          import: () => {
+            throw 42;
+          },
+        },
+      }
+    ).exports.f(),
+  42
+);
+
+// Test for throwing to JS and then back to Wasm.
+{
+  var wasmThrower;
+  let exports = wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (type 0))
+       (import "m" "import" (func $import (result i32)))
+       (func (export "thrower")
+         (i32.const 42)
+         (throw $exn))
+       (func (export "catcher") (result i32)
+         try (result i32)
+           (call $import)
+         catch $exn
+         end))`,
+    {
+      m: {
+        import: () => {
+          return wasmThrower();
+        },
+      },
+    }
+  ).exports;
+
+  wasmThrower = exports.thrower;
+  assertEq(exports.catcher(), 42);
+}
+
+// Tests for checking the tags of exceptions.
+{
+  let exports = wasmEvalText(
+    `(module
+       (type (func (param i32)))
+       (tag $exn (export "exn") (type 0))
+       (func (export "thrower")
+         (i32.const 42)
+         (throw $exn)))`
+  ).exports;
+
+  let imports = {
+    store: {
+      throws: () => {
+        return exports.thrower();
+      },
+      exn: exports.exn,
+    },
+  };
+
+  // This passes the exception tag check and the exception is caught.
+  assertEq(
+    wasmEvalText(
+      `(module
+         (type (func (param i32)))
+         (import "store" "throws" (func $thrower (result i32)))
+         (import "store" "exn" (tag $exn (type 0)))
+         (func (export "catches") (result i32)
+           try (result i32)
+             (call $thrower)
+           catch $exn
+             (i32.const 15)
+             (i32.sub)
+           end))`,
+      imports
+    ).exports.catches(),
+    27
+  );
+
+  // This fails the exception tag check, despite the local exception having
+  // a matching signature.
+  assertWasmThrowsExn(() =>
+    wasmEvalText(
+      `(module
+         (type (func (param i32)))
+         (import "store" "throws" (func $thrower (result i32)))
+         (tag $exn (type 0))
+         (func (export "catchesFail") (result i32)
+           try (result i32)
+             (call $thrower)
+           catch $exn ;; This should not recognise $exn, thus not unpack 42.
+           end))`,
+      imports
+    ).exports.catchesFail()
+  );
+}
+
+// Test that JS finally block executes after a Wasm throw.
+assertEq(
+  (() => {
+    try {
+      wasmEvalText(
+        `(module
+           (type (func (param)))
+           (tag $exn (type 0))
+           (func (export "f")
+             (throw $exn)))`
+      ).exports.f();
+    } finally {
+      return true;
+    }
+    return false;
+  })(),
+  true
+);
+
+// Test that a wasm trap that passes through JS cannot be caught in Wasm.
+{
+  let throwTrap = wasmEvalText(`(module (func (export "f") unreachable))`)
+    .exports.f;
+  let catcher = wasmEvalText(
+    `(module
+       (type (func))
+       (tag $exn (type 0))
+       (import "m" "f" (func $foreign (param) (result)))
+       (func (export "f")
+         try
+           call $foreign
+         catch $exn
+         catch_all
+         end))`,
+    {
+      m: {
+        // JS frame that goes between the two wasm frames and just rethrows.
+        f: () => {
+          try {
+            throwTrap();
+          } catch (e) {
+            throw e;
+          }
+        },
+      },
+    }
+  ).exports.f;
+
+  assertErrorMessage(
+    () => catcher(),
+    WebAssembly.RuntimeError,
+    "unreachable executed"
+  );
+}
+
+// Test delegate throwing out of function.
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           throw $exn
+         delegate 0))`
+  ).exports.f()
+);
+
+assertWasmThrowsExn(() =>
+  wasmEvalText(
+    `(module
+       (tag $exn (param))
+       (func (export "f") (result i32)
+         try (result i32)
+           i32.const 0
+           if
+             i32.const 1
+             return
+           else
+             throw $exn
+           end
+           i32.const 0
+         delegate 0))`
+  ).exports.f()
+);
diff --git a/js/src/jit-test/tests/wasm/exceptions/validation.js b/js/src/jit-test/tests/wasm/exceptions/validation.js
new file mode 100644
index 0000000000..98a37042f1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/exceptions/validation.js
@@ -0,0 +1,662 @@
+
+// Test wasm type validation for exception handling instructions.
+
+load(libdir + "wasm-binary.js");
+
+function wasmValid(mod) {
+  assertEq(WebAssembly.validate(mod), true);
+}
+
+function wasmInvalid(mod, pattern) {
+  assertEq(WebAssembly.validate(mod), false);
+  assertErrorMessage(
+    () => new WebAssembly.Module(mod),
+    WebAssembly.CompileError,
+    pattern
+  );
+}
+
+const emptyType = { args: [], ret: VoidCode };
+const i32Type = { args: [I32Code], ret: VoidCode };
+const toi32Type = { args: [], ret: I32Code };
+const i32Toi32Type = { args: [I32Code], ret: I32Code };
+const i32Toi64Type = { args: [I32Code], ret: I64Code };
+const i32i32Toi32Type = { args: [I32Code, I32Code], ret: I32Code };
+
+function testValidateDecode() {
+  // Try blocks must have a block type code.
+  wasmInvalid(
+    moduleWithSections([
+      sigSection([emptyType]),
+      declSection([0]),
+      tagSection([{ type: 0 }]),
+      bodySection([
+        funcBody({
+          locals: [],
+          body: [
+            TryCode,
+            // Missing type code.
+            I32ConstCode,
+            0x01,
+            CatchCode,
+            0x00,
+            EndCode,
+            DropCode,
+            ReturnCode,
+          ],
+        }),
+      ]),
+    ]),
+    /bad type/
+  );
+
+  // Catch must have a tag index.
+  wasmInvalid(
+    moduleWithSections([
+      sigSection([emptyType]),
+      declSection([0]),
+      tagSection([{ type: 0 }]),
+      bodySection([
+        funcBody(
+          {
+            locals: [],
+            body: [
+              TryCode,
+              I32Code,
+              I32ConstCode,
+              0x01,
+              CatchCode,
+              // Index missing.
+            ],
+          },
+          (withEndCode = false)
+        ),
+      ]),
+    ]),
+    /expected tag index/
+  );
+
+  // Rethrow must have a depth argument.
+  wasmInvalid(
+    moduleWithSections([
+      sigSection([emptyType]),
+      declSection([0]),
+      tagSection([{ type: 0 }]),
+      bodySection([
+        funcBody(
+          {
+            locals: [],
+            body: [
+              RethrowCode,
+              // Index missing.
+            ],
+          },
+          (withEndCode = false)
+        ),
+      ]),
+    ]),
+    /unable to read rethrow depth/
+  );
+
+  // Delegate must have a depth argument.
+  wasmInvalid(
+    moduleWithSections([
+      sigSection([emptyType]),
+      declSection([0]),
+      tagSection([{ type: 0 }]),
+      bodySection([
+        funcBody(
+          {
+            locals: [],
+            body: [
+              TryCode,
+              I32Code,
+              I32ConstCode,
+              0x01,
+              DelegateCode,
+              // Index missing.
+            ],
+          },
+          (withEndCode = false)
+        ),
+      ]),
+    ]),
+    /unable to read delegate depth/
+  );
+}
+
+function testValidateThrow() {
+  valid = `(module
+             (type (func (param i32)))
+             (func $exn-zero
+               i32.const 0
+               throw $exn1)
+             (tag $exn1 (type 0)))`;
+
+  validSimd = `(module
+                (tag $exn (param v128))
+                (func (export "f") (param v128) (result v128)
+                  (try (result v128)
+                    (do (v128.const f64x2 1 2)
+                        (throw $exn))
+                    (catch $exn))))`;
+
+  invalid0 = `(module
+                (type (func (param i32)))
+                (func $exn-zero
+                  throw $exn1)
+                (tag $exn1 (type 0)))`;
+  error0 = /popping value from empty stack/;
+
+  invalid1 = `(module
+                (type (func (param i32)))
+                (func $exn-zero
+                  i64.const 0
+                  throw $exn1)
+                (tag $exn1 (type 0)))`;
+  error1 = /expression has type i64 but expected i32/;
+
+  invalid2 = `(module
+                (type (func (param i32)))
+                (func $exn-zero
+                  i32.const 0
+                  throw 1)
+                (tag $exn1 (type 0)))`;
+  error2 = /tag index out of range/;
+
+  wasmValidateText(valid);
+  if (wasmSimdEnabled()) {
+    wasmValidateText(validSimd);
+  }
+  wasmFailValidateText(invalid0, error0);
+  wasmFailValidateText(invalid1, error1);
+  wasmFailValidateText(invalid2, error2);
+}
+
+function testValidateTryCatch() {
+  function mod_with(fbody) {
+    return moduleWithSections([
+      sigSection([emptyType, i32Type, i32i32Toi32Type]),
+      declSection([0]),
+      tagSection([{ type: 0 }, { type: 1 }]),
+      bodySection([
+        funcBody({
+          locals: [],
+          body: fbody,
+        }),
+      ]),
+    ]);
+  }
+
+  const body1 = [
+    // try (result i32)
+    TryCode,
+    I32Code,
+    // (i32.const 1)
+    I32ConstCode,
+    varU32(1),
+    // catch 1
+    CatchCode,
+    varU32(1),
+  ];
+
+  const valid1 = mod_with(body1.concat([EndCode, DropCode, ReturnCode]));
+  const invalid1 = mod_with(
+    body1.concat([I32ConstCode, varU32(2), EndCode, DropCode, ReturnCode])
+  );
+
+  const valid2 = mod_with([
+    // (i32.const 0) (i32.const 0)
+    I32ConstCode,
+    varU32(0),
+    I32ConstCode,
+    varU32(0),
+    // try (param i32 i32) (result i32) drop drop (i32.const 1)
+    TryCode,
+    varS32(2),
+    DropCode,
+    DropCode,
+    I32ConstCode,
+    varU32(1),
+    // catch 0 (i32.const 2) end drop return
+    CatchCode,
+    varU32(0),
+    I32ConstCode,
+    varU32(2),
+    EndCode,
+    DropCode,
+    ReturnCode,
+  ]);
+
+  wasmValid(valid1);
+  wasmInvalid(invalid1, /unused values not explicitly dropped/);
+  wasmValid(valid2);
+
+  // Test handler-less try blocks.
+  wasmValidateText(
+    `(module (func try end))`
+  );
+
+  wasmValidateText(
+    `(module (func (result i32) try (result i32) (i32.const 1) end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (func (result i32)
+         try (result i32) (i32.const 1) (br 0) end))`
+  );
+
+  wasmFailValidateText(
+    `(module
+       (func try (result i32) end))`,
+    /popping value from empty stack/
+  );
+}
+
+function testValidateCatch() {
+  wasmInvalid(
+    moduleWithSections([
+      sigSection([emptyType]),
+      declSection([0]),
+      bodySection([
+        funcBody({
+          locals: [],
+          body: [TryCode, VoidCode, CatchCode, varU32(0), EndCode],
+        }),
+      ]),
+    ]),
+    /tag index out of range/
+  );
+}
+
+function testValidateCatchAll() {
+  wasmValidateText(
+    `(module
+       (tag $exn)
+       (func try catch $exn catch_all end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (func (result i32)
+         try (result i32)
+           (i32.const 0)
+         catch_all
+           (i32.const 1)
+         end))`
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn)
+       (func try catch_all catch 0 end))`,
+    /catch cannot follow a catch_all/
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn)
+       (func try (result i32) (i32.const 1) catch_all end drop))`,
+    /popping value from empty stack/
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn (param i32))
+       (func try catch $exn drop catch_all drop end))`,
+    /popping value from empty stack/
+  );
+
+  // We can't distinguish `else` and `catch_all` in error messages since they
+  // share the binary opcode.
+  wasmFailValidateText(
+    `(module
+       (tag $exn)
+       (func try catch_all catch_all end))`,
+    /catch_all can only be used within a try/
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn)
+       (func catch_all))`,
+    /catch_all can only be used within a try/
+  );
+}
+
+function testValidateExnPayload() {
+  valid0 = moduleWithSections([
+    sigSection([i32Type, i32Toi32Type]),
+    declSection([1]),
+    // (tag $exn (param i32))
+    tagSection([{ type: 0 }]),
+    bodySection([
+      // (func (param i32) (result i32) ...
+      funcBody({
+        locals: [],
+        body: [
+          // try (result i32) (local.get 0) (throw $exn) (i32.const 1)
+          TryCode,
+          I32Code,
+          LocalGetCode,
+          varU32(0),
+          ThrowCode,
+          varU32(0),
+          I32ConstCode,
+          varU32(1),
+          // catch $exn (i32.const 1) (i32.add) end
+          CatchCode,
+          varU32(0),
+          I32ConstCode,
+          varU32(1),
+          I32AddCode,
+          EndCode,
+        ],
+      }),
+    ]),
+  ]);
+
+  // This is to ensure the following sentence from the spec overview holds:
+  // > "the operand stack is popped back to the size the operand stack had
+  // > when the try block was entered"
+  valid1 = moduleWithSections([
+    sigSection([i32Type, toi32Type]),
+    declSection([1]),
+    // (tag $exn (param i32))
+    tagSection([{ type: 0 }]),
+    bodySection([
+      // (func (result i32) ...
+      funcBody({
+        locals: [],
+        body: [
+          // try (result i32) (i32.const 0) (i32.const 1) (throw $exn) drop
+          TryCode,
+          I32Code,
+          I32ConstCode,
+          varU32(0),
+          I32ConstCode,
+          varU32(1),
+          ThrowCode,
+          varU32(0),
+          DropCode,
+          // catch $exn drop (i32.const 2) end
+          CatchCode,
+          varU32(0),
+          DropCode,
+          I32ConstCode,
+          varU32(2),
+          EndCode,
+        ],
+      }),
+    ]),
+  ]);
+
+  invalid0 = moduleWithSections([
+    sigSection([i32Type, i32Toi64Type]),
+    declSection([1]),
+    // (tag $exn (param i32))
+    tagSection([{ type: 0 }]),
+    bodySection([
+      // (func (param i32) (result i64) ...
+      funcBody({
+        locals: [],
+        body: [
+          // try (result i64) (local.get 0) (throw $exn) (i64.const 0)
+          TryCode,
+          I64Code,
+          LocalGetCode,
+          varU32(0),
+          ThrowCode,
+          varU32(0),
+          I64ConstCode,
+          varU32(0),
+          // catch $exn end
+          CatchCode,
+          varU32(0),
+          EndCode,
+        ],
+      }),
+    ]),
+  ]);
+
+  invalid1 = moduleWithSections([
+    // (type (func))
+    sigSection([emptyType]),
+    declSection([0]),
+    // (tag $exn (type 0))
+    tagSection([{ type: 0 }]),
+    bodySection([
+      // (func ...
+      funcBody({
+        locals: [],
+        body: [
+          // try catch 1 end
+          TryCode,
+          VoidCode,
+          CatchCode,
+          varU32(1),
+          EndCode,
+        ],
+      }),
+    ]),
+  ]);
+
+  wasmValid(valid0);
+  wasmValid(valid1);
+  wasmInvalid(invalid0, /has type i32 but expected i64/);
+  wasmInvalid(invalid1, /tag index out of range/);
+}
+
+function testValidateRethrow() {
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           nop
+         catch $exn
+           rethrow 0
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           nop
+         catch_all
+           rethrow 0
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (func (result i32)
+         try (result i32)
+           (i32.const 1)
+         catch_all
+           rethrow 0
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           nop
+         catch $exn
+           block
+             try
+             catch $exn
+               rethrow 0
+             end
+           end
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           nop
+         catch $exn
+           block
+             try
+             catch $exn
+               rethrow 2
+             end
+           end
+         end))`
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           nop
+         catch $exn
+           block
+             try
+             catch $exn
+               rethrow 1
+             end
+           end
+         end))`,
+    /rethrow target was not a catch block/
+  );
+
+  wasmFailValidateText(
+    `(module (func rethrow 0))`,
+    /rethrow target was not a catch block/
+  );
+
+  wasmFailValidateText(
+    `(module (func try rethrow 0 end))`,
+    /rethrow target was not a catch block/
+  );
+
+  wasmFailValidateText(
+    `(module (func try rethrow 0 catch_all end))`,
+    /rethrow target was not a catch block/
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           nop
+         catch $exn
+           block
+             try
+             catch $exn
+               rethrow 4
+             end
+           end
+         end))`,
+    /rethrow depth exceeds current nesting level/
+  );
+}
+
+function testValidateDelegate() {
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           try
+             throw $exn
+           delegate 0
+         catch $exn
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           try
+             throw $exn
+           delegate 1
+         catch $exn
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         block
+           try
+             throw $exn
+           delegate 0
+         end))`
+  );
+
+  wasmValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+         catch $exn
+           try
+             throw $exn
+           delegate 0
+         end))`
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn (param))
+       (func (result i32)
+         try
+           throw $exn
+         delegate 0
+         (i64.const 0)
+         end))`,
+    /type mismatch: expression has type i64 but expected i32/
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try (result i32)
+           (i64.const 0)
+         delegate 0))`,
+    /type mismatch: expression has type i64 but expected i32/
+  );
+
+  wasmFailValidateText(
+    `(module
+       (tag $exn (param))
+       (func
+         try
+           try
+             throw $exn
+           delegate 2
+         catch $exn
+         end))`,
+    /delegate depth exceeds current nesting level/
+  );
+
+  wasmFailValidateText(
+    `(module (func delegate 0))`,
+    /delegate can only be used within a try/
+  );
+}
+
+testValidateDecode();
+testValidateThrow();
+testValidateTryCatch();
+testValidateCatch();
+testValidateCatchAll();
+testValidateExnPayload();
+testValidateRethrow();
+testValidateDelegate();
diff --git a/js/src/jit-test/tests/wasm/extended-const/basic.js b/js/src/jit-test/tests/wasm/extended-const/basic.js
new file mode 100644
index 0000000000..bf0ce460d5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/extended-const/basic.js
@@ -0,0 +1,95 @@
+// |jit-test| skip-if: !wasmExtendedConstEnabled()
+
+function testPrivateGlobal(valtype, expr, result) {
+  // Immutable private globals have a single cell for wasm.
+  let { get } = wasmEvalText(`(module
+    (global $global ${valtype} ${expr})
+    (func (export "get") (result ${valtype})
+      global.get $global
+    )
+  )`).exports;
+  assertEq(get(), result);
+}
+function testExportedGlobal(valtype, expr, result) {
+  // Immutable exported globals have a separate cell for wasm and the exported
+  // global object.
+  let { global, get } = wasmEvalText(`(module
+    (global $global (export "global") ${valtype} ${expr})
+    (func (export "get") (result ${valtype})
+      global.get $global
+    )
+  )`).exports;
+  assertEq(get(), result);
+  assertEq(global.value, result);
+}
+function testIndirectGlobal(valtype, expr, result) {
+  // Mutable exported globals share an indirect cell for wasm and the exported
+  // global object.
+  let { global } = wasmEvalText(`(module
+    (global (export "global") (mut ${valtype}) ${expr})
+  )`).exports;
+  assertEq(global.value, result);
+}
+
+// i32 tests
+
+const I32_SQ_OVERFLOW = 0xFFFF + 1;
+const MAX_I32 = 0xFFFF_FFFF;
+function testI32(expr, result) {
+  testPrivateGlobal('i32', expr, result);
+  testExportedGlobal('i32', expr, result);
+  testIndirectGlobal('i32', expr, result);
+}
+testI32('i32.const 1', 1);
+
+testI32('i32.const 1 i32.const 2 i32.add', 3);
+testI32(`i32.const ${MAX_I32} i32.const 1 i32.add`, 0);
+
+testI32('i32.const 1 i32.const 2 i32.sub', -1);
+testI32(`i32.const 1 i32.const 0 i32.sub`, 1);
+
+testI32('i32.const 1 i32.const 2 i32.mul', 2);
+testI32(`i32.const ${I32_SQ_OVERFLOW} i32.const ${I32_SQ_OVERFLOW} i32.mul`, 0);
+
+// i64 tests
+
+const I64_SQ_OVERFLOW = 0xFFFF_FFFFn + 1n;
+const MAX_I64 = 0xFFFF_FFFF_FFFF_FFFFn;
+function testI64(expr, result) {
+  testPrivateGlobal('i64', expr, result);
+  testExportedGlobal('i64', expr, result);
+  testIndirectGlobal('i64', expr, result);
+}
+testI64('i64.const 1', 1n);
+
+testI64('i64.const 1 i64.const 2 i64.add', 3n);
+testI64(`i64.const ${MAX_I64} i64.const 1 i64.add`, 0n);
+
+testI64('i64.const 1 i64.const 2 i64.sub', -1n);
+testI64(`i64.const 1 i64.const 0 i64.sub`, 1n);
+
+testI64('i64.const 1 i64.const 2 i64.mul', 2n);
+testI64(`i64.const ${I64_SQ_OVERFLOW} i64.const ${I64_SQ_OVERFLOW} i64.mul`, 0n);
+
+// test global.get
+
+function testGlobalGet(valtype, aExpr, bExpr, cExpr, cResult) {
+  let { a, b } = wasmEvalText(`(module
+    (global (export "a") ${valtype} ${aExpr})
+    (global (export "b") ${valtype} ${bExpr})
+  )`).exports;
+  let { c } = wasmEvalText(`(module
+    (global $a (import "" "a") ${valtype})
+    (global $b (import "" "b") ${valtype})
+    (global (export "c") ${valtype} ${cExpr})
+  )`, {"": {a, b}}).exports;
+  assertEq(c.value, cResult);
+}
+
+testGlobalGet('i32', 'i32.const 2', 'i32.const 3', 'global.get $a global.get $b i32.add', 5);
+testGlobalGet('i32', 'i32.const 2', 'i32.const 3', 'global.get $a global.get $b i32.sub', -1);
+testGlobalGet('i32', 'i32.const 2', 'i32.const 3', 'global.get $a global.get $b i32.mul', 6);
+
+testGlobalGet('i64', 'i64.const 2', 'i64.const 3', 'global.get $a global.get $b i64.add', 5n);
+testGlobalGet('i64', 'i64.const 2', 'i64.const 3', 'global.get $a global.get $b i64.sub', -1n);
+testGlobalGet('i64', 'i64.const 2', 'i64.const 3', 'global.get $a global.get $b i64.mul', 6n);
diff --git a/js/src/jit-test/tests/wasm/extended-const/directives.txt b/js/src/jit-test/tests/wasm/extended-const/directives.txt
new file mode 100644
index 0000000000..0d16de6524
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/extended-const/directives.txt
@@ -0,0 +1 @@
+|jit-test| --wasm-extended-const; test-also=--wasm-compiler=optimizing; test-also=--wasm-test-serialization; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/extended-const/disabled.js b/js/src/jit-test/tests/wasm/extended-const/disabled.js
new file mode 100644
index 0000000000..01e64f6c44
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/extended-const/disabled.js
@@ -0,0 +1,22 @@
+// |jit-test| skip-if: wasmExtendedConstEnabled()
+
+const { CompileError, validate } = WebAssembly;
+
+const DISABLED = /extended constant expressions not enabled|unrecognized opcode/;
+
+let tests = [
+    "(module (global i32 i32.const 0 i32.const 0 i32.add))",
+    "(module (global i32 i32.const 0 i32.const 0 i32.sub))",
+    "(module (global i32 i32.const 0 i32.const 0 i32.mul))",
+    "(module (global i64 i64.const 0 i64.const 0 i64.add))",
+    "(module (global i64 i64.const 0 i64.const 0 i64.sub))",
+    "(module (global i64 i64.const 0 i64.const 0 i64.mul))",
+];
+
+// Test that use of extended constants fails when disabled.
+
+for (let src of tests) {
+    let bin = wasmTextToBinary(src);
+    assertEq(validate(bin), false);
+    wasmCompilationShouldFail(bin, DISABLED);
+}
diff --git a/js/src/jit-test/tests/wasm/extended-const/pathological.js b/js/src/jit-test/tests/wasm/extended-const/pathological.js
new file mode 100644
index 0000000000..e3695f3625
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/extended-const/pathological.js
@@ -0,0 +1,78 @@
+// |jit-test| skip-if: !wasmExtendedConstEnabled()
+
+// Let's calculate zero in some elaborate ways.
+function testFancyZeroOffset(fancyZero, memType = 'i32') {
+    try {
+        const { mem } = wasmEvalText(`(module
+            (memory (export "mem") ${memType} 1)
+            (data (offset ${fancyZero}) "hi")
+        )`).exports;
+        const str = String.fromCharCode(...new Uint8Array(mem.buffer).slice(0, 2));
+        assertEq(str, 'hi');
+    } catch (e) {
+        const { getOffset } = wasmEvalText(`(module
+            (func (export "getOffset") (result ${memType})
+                ${fancyZero}
+            )
+        )`).exports;
+        console.log('Computed offset:', getOffset());
+        throw e;
+    }
+}
+
+// Do plus one minus one a thousand times
+testFancyZeroOffset('i32.const 0 ' + (
+    '(i32.add (i32.const 1)) '
+    + '(i32.sub (i32.const 1)) '
+).repeat(1000));
+
+// Do some jank fibonacci
+{
+    let fib = '(i32.const 1)\n'
+    let a = 1; let b = 1; let next;
+    for (let i = 0; i < 45; i++) {
+        fib += `(i32.const ${a})\n`;
+        fib += '(i32.add)\n';
+        next = a + b;
+        a = b;
+        b = next;
+    }
+    fib += `(i32.sub (i32.const ${next}))\n`;
+    testFancyZeroOffset(fib);
+}
+
+// Run the collatz conjecture as long as possible
+{
+    let val = 837799; // should reach 1 in 524 steps
+    let expr = `(i32.const ${val})\n`;
+    while (val != 1) {
+        if (val % 2 == 0) {
+            expr += `(i32.sub (i32.const ${val / 2}))\n`; // we can't divide in constant expressions lol
+            val /= 2;
+        } else {
+            expr += `(i32.mul (i32.const 3))\n`;
+            expr += `(i32.add (i32.const 1))\n`;
+            val = val * 3 + 1;
+        }
+    }
+    expr += `(i32.sub (i32.const 1))\n`;
+    testFancyZeroOffset(expr);
+}
+
+// The collatz conjecture would be even more fun with 64-bit numbers...
+if (wasmMemory64Enabled()) {
+    let val = 1899148184679; // should reach 1 in 1411 steps
+    let expr = `(i64.const ${val})\n`;
+    while (val != 1) {
+        if (val % 2 == 0) {
+            expr += `(i64.sub (i64.const ${val / 2}))\n`; // we can't divide in constant expressions lol
+            val /= 2;
+        } else {
+            expr += `(i64.mul (i64.const 3))\n`;
+            expr += `(i64.add (i64.const 1))\n`;
+            val = val * 3 + 1;
+        }
+    }
+    expr += `(i64.sub (i64.const 1))\n`;
+    testFancyZeroOffset(expr, 'i64');
+}
diff --git a/js/src/jit-test/tests/wasm/extract-code.js b/js/src/jit-test/tests/wasm/extract-code.js
new file mode 100644
index 0000000000..c2c3163652
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/extract-code.js
@@ -0,0 +1,12 @@
+var module = new WebAssembly.Module(wasmTextToBinary(`(module (func (nop)))`));
+var exp = wasmExtractCode(module, "stable");
+assertEq(exp.code instanceof Uint8Array, true);
+assertEq(Array.isArray(exp.segments), true);
+var funcs = exp.segments.filter(s => s.kind === 0);
+assertEq(funcs.length, 1);
+assertEq(funcs[0].funcIndex, 0);
+assertEq(funcs[0].begin >= 0, true);
+assertEq(funcs[0].begin <= funcs[0].funcBodyBegin, true);
+assertEq(funcs[0].funcBodyBegin < funcs[0].funcBodyEnd, true);
+assertEq(funcs[0].funcBodyEnd <= funcs[0].end, true);
+assertEq(funcs[0].end <= exp.code.length, true);
diff --git a/js/src/jit-test/tests/wasm/fac.js b/js/src/jit-test/tests/wasm/fac.js
new file mode 100644
index 0000000000..5b3435a389
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/fac.js
@@ -0,0 +1,19 @@
+// This is fac-opt from fac.wast in the official testsuite, changed to use
+// i32 instead of i64.
+assertEq(wasmEvalText(`(module
+  (func $fac-opt (param i32) (result i32)
+    (local i32)
+    (local.set 1 (i32.const 1))
+    (block
+      (br_if 0 (i32.lt_s (local.get 0) (i32.const 2)))
+      (loop
+        (local.set 1 (i32.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i32.add (local.get 0) (i32.const -1)))
+        (br_if 0 (i32.gt_s (local.get 0) (i32.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+
+  (export "" (func 0))
+)`).exports[""](10), 3628800);
diff --git a/js/src/jit-test/tests/wasm/features.js b/js/src/jit-test/tests/wasm/features.js
new file mode 100644
index 0000000000..f6b21ff7b6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/features.js
@@ -0,0 +1,93 @@
+// |jit-test| test-also=--wasm-extended-const; test-also=--wasm-exceptions; test-also=--wasm-function-references; test-also=--wasm-gc
+
+// Test that if a feature is 'experimental' then we must be in a nightly build,
+// and if a feature is 'released' then it must be enabled on release and beta.
+//
+// An experimental feature is allowed to be disabled by platform/feature flags,
+// we only require that it can never be enabled on release/beta builds.
+//
+// A released feature is allowed to be disabled on nightly. This is useful for
+// if we're testing out a new compiler/configuration where a released feature
+// is not supported yet. We only require that on release/beta, the feature must
+// be enabled.
+//
+// As features are advanced, this test must be manually updated.
+//
+// NOTE0: The |jit-test| directive must be updated with all opt-in shell flags
+//        for experimental features for this to work correctly.
+// NOTE1: This test relies on feature functions accurately guarding use of the
+//        feature to work correctly. All features should have a 'disabled.js'
+//        test to verify this. Basic testing for this is included with each
+//        feature in this test for sanity.
+
+let { release_or_beta } = getBuildConfiguration();
+let nightly = !release_or_beta;
+
+let nightlyOnlyFeatures = [
+  [
+    'function-references',
+    wasmFunctionReferencesEnabled(),
+    `(module (func (param (ref extern))))`
+  ],
+  [
+    'gc',
+    wasmGcEnabled(),
+    `(module (type $s (struct)) (func (param (ref null $s))))`
+  ],
+];
+
+for (let [name, enabled, test] of nightlyOnlyFeatures) {
+  if (enabled) {
+    assertEq(nightly, true, `${name} must be enabled only on nightly`);
+    wasmEvalText(test);
+  } else {
+    assertErrorMessage(() => wasmEvalText(test), WebAssembly.CompileError, /./);
+  }
+}
+
+// These are features that are enabled in beta/release but may be disabled at
+// run-time for other reasons.  The best we can do for these features is to say
+// that if one claims to be supported then it must work, and otherwise there
+// must be a CompileError.
+
+let releasedFeaturesMaybeDisabledAnyway = [
+  // SIMD will be disabled dynamically on x86/x64 if the hardware isn't SSE4.1+.
+  ['simd', wasmSimdEnabled(), `(module (func (result v128) i32.const 0 i8x16.splat))`]
+];
+
+for (let [name, enabled, test] of releasedFeaturesMaybeDisabledAnyway) {
+  if (release_or_beta) {
+    if (enabled) {
+      wasmEvalText(test);
+    } else {
+      assertErrorMessage(() => wasmEvalText(test), WebAssembly.CompileError, /./);
+    }
+  }
+}
+
+let releasedFeatures = [
+  ['threads', wasmThreadsEnabled(), `(module (memory 1 1 shared))`],
+  [
+    'exceptions',
+    wasmExceptionsEnabled(),
+    `(module (type (func)) (tag (type 0)))`
+  ],
+  [
+    'extended-const',
+    wasmExtendedConstEnabled(),
+    `(module
+      (global i32
+        i32.const 0
+        i32.const 0
+        i32.add
+      )
+    )`
+  ],
+];
+
+for (let [name, enabled, test] of releasedFeatures) {
+  if (release_or_beta) {
+    assertEq(enabled, true, `${name} must be enabled on release and beta`);
+    wasmEvalText(test);
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/fence.js b/js/src/jit-test/tests/wasm/fence.js
new file mode 100644
index 0000000000..1b839bb9f9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/fence.js
@@ -0,0 +1,24 @@
+// |jit-test| skip-if: !wasmThreadsEnabled()
+
+// Test that `atomic.fence` is a valid instruction of type `[] -> []`
+wasmFullPass(
+`(module
+	(func atomic.fence)
+	(export "run" (func 0))
+)`);
+
+// Test that `atomic.fence` works with non-shared memory
+wasmFullPass(
+`(module
+	(memory 1)
+	(func atomic.fence)
+	(export "run" (func 0))
+)`);
+
+// Test that `atomic.fence` works with shared memory
+wasmFullPass(
+`(module
+	(memory 1 1 shared)
+	(func atomic.fence)
+	(export "run" (func 0))
+)`);
diff --git a/js/src/jit-test/tests/wasm/float-unaligned.js b/js/src/jit-test/tests/wasm/float-unaligned.js
new file mode 100644
index 0000000000..a22ffe5fee
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/float-unaligned.js
@@ -0,0 +1,118 @@
+// Various tests for unaligned float accesses.  These are specifically meant to
+// test the SIGBUS handling on 32-bit ARM by exercising odd addresses and odd
+// offsets.
+
+// For a triple of (numBallast, ty, offset), create the text for a pair of
+// functions "get_ty_offset" and "set_ty_offset" where each has numBallast live
+// dummy values across the operation of interest to force the use of different
+// register numbers.  (This is primarily for the FP registers as ARM code
+// generation currently always uses the same scratch register for the base
+// address of the access.)
+//
+// These must be augmented with a memory.  Memory addresses 0-255 are reserved
+// for internal use by these functions.  The memory must start as zero.
+
+function makeLoadStore(numBallast, ty, offset) {
+    // The general idea of the ballast is that we occupy some FP registers and
+    // some int registers with non-dead values before we perform an operation,
+    // and then we consume the occupied registers after.
+    //
+    // In the case of load, the loaded result is stored back in memory before we
+    // consume the ballast, thus the ion regalloc will not simply always load
+    // the result into d0, but usually into some temp other than d0.  Thus the
+    // amount of ballast affects the register.  (Ditto baseline though the
+    // reasoning is simpler.)
+    //
+    // In the case of store, we keep the parameter value live until the end so
+    // that the tmp that we compute for the store is moved into a different
+    // register.  The tmp has the same value as the parameter value but a
+    // non-JIT compiler can't know that.
+
+    let loadtxt =
+      `(func (export "get_${ty}_${offset}") (param $p i32) (result ${ty})
+         ${ballast(() => `
+              (i32.const 8)
+              (i32.store (i32.const 8) (i32.add (i32.load (i32.const 8)) (i32.const 1)))
+              (${ty}.load (i32.const 8))`)}
+
+         (${ty}.store (i32.const 0) (${ty}.load offset=${offset} (local.get $p)))
+
+         ${ballast(() => `
+             ${ty}.store`)}
+
+         (${ty}.load (i32.const 0)))`;
+
+    // This will assume the value at mem[16] is zero.
+    let storetxt =
+      `(func (export "set_${ty}_${offset}") (param $p i32) (param $v ${ty})
+         (local $tmp ${ty})
+         ${ballast(() => `
+              (i32.const 8)
+              (i32.store (i32.const 8) (i32.add (i32.load (i32.const 8)) (i32.const 1)))
+              (${ty}.load (i32.const 8))`)}
+
+         (local.set $tmp (${ty}.add (local.get $v) (${ty}.load (i32.const 16))))
+         (${ty}.store offset=${offset} (local.get $p) (local.get $tmp))
+
+         ${ballast(() => `
+             ${ty}.store`)}
+         (${ty}.store (i32.const 8) (local.get $v)))`;
+
+    return `${loadtxt}
+            ${storetxt}`;
+
+    function ballast(thunk) {
+        let s = "";
+        for ( let i=0 ; i < numBallast; i++ )
+            s += thunk();
+        return s;
+    }
+}
+
+// The complexity here comes from trying to force the source/target FP registers
+// in the FP access instruction to vary.  For Baseline this is not hard; for Ion
+// trickier.
+
+function makeInstance(numBallast, offset) {
+    let txt =
+        `(module
+           (memory (export "memory") 1 1)
+           ${makeLoadStore(numBallast, 'f64', offset)}
+           ${makeLoadStore(numBallast, 'f32', offset)})`;
+    return new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(txt)));
+}
+
+// `offset` corresponds to the "offset" directive in the instruction
+for ( let offset=0 ; offset < 8; offset++ ) {
+
+    // `numBallast` represents the amount of ballast registers we're trying to use,
+    // see comments above.
+    for ( let numBallast=0; numBallast < 16; numBallast++ ) {
+        let ins = makeInstance(numBallast, offset);
+        let mem = ins.exports.memory;
+        let buf = new DataView(mem.buffer);
+
+        // `i` represents the offset in the pointer from a proper boundary
+        for ( let i=0; i < 9; i++ ) {
+	    let offs = 256+i;
+            let val = Math.PI+i;
+
+            buf.setFloat64(offs + offset, val, true);
+            assertEq(ins.exports["get_f64_" + offset](offs), val);
+
+            ins.exports["set_f64_" + offset](offs + 32, val);
+            assertEq(buf.getFloat64(offs + 32 + offset, true), val);
+        }
+
+        for ( let i=0; i < 9; i++ ) {
+            let offs = 512+i;
+            let val = Math.fround(Math.PI+i);
+
+            buf.setFloat32(offs + offset, val, true);
+            assertEq(ins.exports["get_f32_" + offset](offs), val);
+
+            ins.exports["set_f32_" + offset](offs + 32, val);
+            assertEq(buf.getFloat32(offs + 32 + offset, true), val);
+        }
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/float.js b/js/src/jit-test/tests/wasm/float.js
new file mode 100644
index 0000000000..fe86ac1801
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/float.js
@@ -0,0 +1,103 @@
+wasmFullPass('(module (func (result f32) (f32.const -1)) (export "run" (func 0)))', -1);
+wasmFullPass('(module (func (result f32) (f32.const 1)) (export "run" (func 0)))', 1);
+wasmFullPass('(module (func (result f64) (f64.const -2)) (export "run" (func 0)))', -2);
+wasmFullPass('(module (func (result f64) (f64.const 2)) (export "run" (func 0)))', 2);
+wasmFullPass('(module (func (result f64) (f64.const 4294967296)) (export "run" (func 0)))', 4294967296);
+wasmFullPass('(module (func (result f32) (f32.const 1.5)) (export "run" (func 0)))', 1.5);
+wasmFullPass('(module (func (result f64) (f64.const 2.5)) (export "run" (func 0)))', 2.5);
+wasmFullPass('(module (func (result f64) (f64.const 10e2)) (export "run" (func 0)))', 10e2);
+wasmFullPass('(module (func (result f32) (f32.const 10e2)) (export "run" (func 0)))', 10e2);
+wasmFullPass('(module (func (result f64) (f64.const -0x8000000000000000)) (export "run" (func 0)))', -0x8000000000000000);
+wasmFullPass('(module (func (result f64) (f64.const -9223372036854775808)) (export "run" (func 0)))', -9223372036854775808);
+wasmFullPass('(module (func (result f64) (f64.const 1797693134862315708145274e284)) (export "run" (func 0)))', 1797693134862315708145274e284);
+
+function testUnary(type, opcode, op, expect) {
+    wasmFullPass('(module (func (param ' + type + ') (result ' + type + ') (' + type + '.' + opcode + ' (local.get 0))) (export "run" (func 0)))',
+                 expect,
+                 {},
+                 op);
+}
+
+function testBinary(type, opcode, lhs, rhs, expect) {
+    wasmFullPass('(module (func (param ' + type + ') (param ' + type + ') (result ' + type + ') (' + type + '.' + opcode + ' (local.get 0) (local.get 1))) (export "run" (func 0)))',
+                 expect,
+                 {},
+                 lhs, rhs);
+}
+
+function testComparison(type, opcode, lhs, rhs, expect) {
+    wasmFullPass('(module (func (param ' + type + ') (param ' + type + ') (result i32) (' + type + '.' + opcode + ' (local.get 0) (local.get 1))) (export "run" (func 0)))',
+                 expect,
+                 {},
+                 lhs, rhs);
+}
+
+testUnary('f32', 'abs', -40, 40);
+testUnary('f32', 'neg', 40, -40);
+testUnary('f32', 'floor', 40.9, 40);
+testUnary('f32', 'ceil', 40.1, 41);
+testUnary('f32', 'nearest', -41.5, -42);
+testUnary('f32', 'trunc', -41.5, -41);
+testUnary('f32', 'sqrt', 40, 6.324555397033691);
+
+testBinary('f32', 'add', 40, 2, 42);
+testBinary('f32', 'sub', 40, 2, 38);
+testBinary('f32', 'mul', 40, 2, 80);
+testBinary('f32', 'div', 40, 3, 13.333333015441895);
+testBinary('f32', 'min', 40, 2, 2);
+testBinary('f32', 'max', 40, 2, 40);
+testBinary('f32', 'copysign', 40, -2, -40);
+
+testComparison('f32', 'eq', 40, 40, 1);
+testComparison('f32', 'ne', 40, 40, 0);
+testComparison('f32', 'lt', 40, 40, 0);
+testComparison('f32', 'le', 40, 40, 1);
+testComparison('f32', 'gt', 40, 40, 0);
+testComparison('f32', 'ge', 40, 40, 1);
+
+testUnary('f64', 'abs', -40, 40);
+testUnary('f64', 'neg', 40, -40);
+testUnary('f64', 'floor', 40.9, 40);
+testUnary('f64', 'ceil', 40.1, 41);
+testUnary('f64', 'nearest', -41.5, -42);
+testUnary('f64', 'trunc', -41.5, -41);
+testUnary('f64', 'sqrt', 40, 6.324555320336759);
+
+testBinary('f64', 'add', 40, 2, 42);
+testBinary('f64', 'sub', 40, 2, 38);
+testBinary('f64', 'mul', 40, 2, 80);
+testBinary('f64', 'div', 40, 3, 13.333333333333334);
+testBinary('f64', 'min', 40, 2, 2);
+testBinary('f64', 'max', 40, 2, 40);
+testBinary('f64', 'copysign', 40, -2, -40);
+
+testComparison('f64', 'eq', 40, 40, 1);
+testComparison('f64', 'ne', 40, 40, 0);
+testComparison('f64', 'lt', 40, 40, 0);
+testComparison('f64', 'le', 40, 40, 1);
+testComparison('f64', 'gt', 40, 40, 0);
+testComparison('f64', 'ge', 40, 40, 1);
+
+wasmFailValidateText('(module (func (param i32) (result f32) (f32.sqrt (local.get 0))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (result i32) (f32.sqrt (local.get 0))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (result i32) (f32.sqrt (local.get 0))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param i32) (result f64) (f64.sqrt (local.get 0))))', mismatchError("i32", "f64"));
+wasmFailValidateText('(module (func (param f64) (result i32) (f64.sqrt (local.get 0))))', mismatchError("f64", "i32"));
+wasmFailValidateText('(module (func (param i32) (result i32) (f64.sqrt (local.get 0))))', mismatchError("i32", "f64"));
+wasmFailValidateText('(module (func (f32.sqrt (nop))))', /(popping value from empty stack)|(type mismatch: expected f32 but nothing on stack)/);
+
+wasmFailValidateText('(module (func (param i32) (param f32) (result f32) (f32.add (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (param i32) (result f32) (f32.add (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (param f32) (result i32) (f32.add (local.get 0) (local.get 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (param i32) (result i32) (f32.add (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param i32) (param f64) (result f64) (f64.add (local.get 0) (local.get 1))))', mismatchError("i32", "f64"));
+wasmFailValidateText('(module (func (param f64) (param i32) (result f64) (f64.add (local.get 0) (local.get 1))))', mismatchError("i32", "f64"));
+wasmFailValidateText('(module (func (param f64) (param f64) (result i32) (f64.add (local.get 0) (local.get 1))))', mismatchError("f64", "i32"));
+wasmFailValidateText('(module (func (param i32) (param i32) (result i32) (f64.add (local.get 0) (local.get 1))))', mismatchError("i32", "f64"));
+
+wasmFailValidateText('(module (func (param i32) (param f32) (result f32) (f32.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (param i32) (result f32) (f32.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (param f32) (result f32) (f32.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param i32) (param f64) (result f64) (f64.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f64"));
+wasmFailValidateText('(module (func (param f64) (param i32) (result f64) (f64.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f64"));
+wasmFailValidateText('(module (func (param f64) (param f64) (result f64) (f64.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f64"));
diff --git a/js/src/jit-test/tests/wasm/full-cycle.js b/js/src/jit-test/tests/wasm/full-cycle.js
new file mode 100644
index 0000000000..7368fc0b7d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/full-cycle.js
@@ -0,0 +1,148 @@
+wasmFullPass(`(module
+    (func $test (param i32) (param i32) (result i32) (i32.add (local.get 0) (local.get 1)))
+    (func $run (result i32) (call $test (i32.const 1) (i32.const ${Math.pow(2, 31) - 1})))
+    (export "run" (func $run))
+)`, -Math.pow(2, 31));
+
+wasmFullPass(`(module
+    (func (result i32)
+        i32.const 1
+        i32.const 42
+        i32.add
+        return
+        unreachable
+        i32.const 0
+        call 3
+        i32.const 42
+        i32.add
+    )
+    (func) (func) (func)
+(export "run" (func 0)))`, 43);
+
+wasmFullPass(`
+(module
+  (import "env" "a" (global $a i32))
+  (import "env" "b" (func $b (param i32) (result i32)))
+  (func (export "run") (param $0 i32) (result i32) local.get 0 call $b)
+)`, 43, { env: { a: 1337, b: x => x+1 } }, 42);
+
+// Global section.
+wasmFullPass(`(module
+ (import "globals" "x" (global $imported i32))
+ (global $mut_local (mut i32) (i32.const 0))
+ (global $imm_local i32 (i32.const 37))
+ (global $imm_local_2 i32 (global.get 0))
+ (func $get (result i32)
+  i32.const 13
+  global.set $mut_local
+  global.get $imported
+  global.get $mut_local
+  i32.add
+  global.get $imm_local
+  i32.add
+  global.get $imm_local_2
+  i32.add
+ )
+ (export "run" (func $get))
+)`, 13 + 42 + 37 + 42, { globals: {x: 42} });
+
+// Memory.
+wasmFullPass(`(module
+    (memory (export "memory") 1 2)
+    (data (i32.const 0) "\\00\\01\\02" "\\03\\04\\05")
+    (data (i32.const 6) "\\06")
+    (func (export "run") (result i32)
+        i32.const 1
+        i32.load offset=2
+    )
+)`, 0x06050403);
+
+let memory = new WebAssembly.Memory({ initial: 1, maximum: 2 });
+
+wasmFullPass(`(module
+    (memory (import "" "memory") 1 2)
+    (data (i32.const 0) "\\00\\01\\02\\03\\04\\05")
+    (func (export "run") (result i32)
+        i32.const 1
+        i32.load offset=2
+    )
+    (export "mem" (memory 0))
+)`, 0x050403, {"": {memory}});
+
+// Tables.
+wasmFullPass(`(module
+    (table (export "table") 3 funcref)
+    (type $t (func (result i32)))
+    (func $foo (result i32) (i32.const 1))
+    (func $bar (result i32) (i32.const 2))
+    (func $baz (result i32) (i32.const 3))
+    (elem (i32.const 0) $baz $bar)
+    (elem (i32.const 2) $foo)
+    (func (export "run") (param i32) (result i32)
+        local.get 0
+        call_indirect (type $t)
+    )
+)`, 3, {}, 0);
+
+let table = new WebAssembly.Table({ element: 'anyfunc', initial: 3, maximum: 3 });
+
+wasmFullPass(`(module
+    (table (import "" "table") 3 4 funcref)
+    (type $t (func (result i32)))
+    (func $foo (result i32) (i32.const 1))
+    (func $bar (result i32) (i32.const 2))
+    (func $baz (result i32) (i32.const 3))
+    (elem (i32.const 0) $baz $bar)
+    (elem (i32.const 2) $foo)
+    (func (export "run") (param i32) (result i32)
+        local.get 0
+        call_indirect (type $t)
+    )
+)`, 3, {"":{table}}, 0);
+
+// Start function.
+wasmFullPass(`(module
+    (global $g (mut i32) (i32.const 0))
+    (func $start
+        global.get $g
+        i32.const 1
+        i32.add
+        global.set $g
+    )
+    (start $start)
+    (func (export "run") (result i32)
+        global.get $g
+    )
+)`, 1);
+
+// Branch table.
+for (let [p, result] of [
+    [0, 7],
+    [1, 6],
+    [2, 4],
+    [42, 4]
+]) {
+    wasmFullPass(`(module
+        (func (export "run") (param $p i32) (result i32) (local $n i32)
+            i32.const 0
+            local.set $n
+            block $c block $b block $a
+                local.get $p
+                br_table $a $b $c
+            end $a
+                local.get $n
+                i32.const 1
+                i32.add
+                local.set $n
+            end $b
+                local.get $n
+                i32.const 2
+                i32.add
+                local.set $n
+            end $c
+            local.get $n
+            i32.const 4
+            i32.add
+        )
+    )`, result, {}, p);
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/as-non-null.js b/js/src/jit-test/tests/wasm/function-references/as-non-null.js
new file mode 100644
index 0000000000..1280c8ee06
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/as-non-null.js
@@ -0,0 +1,13 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+let {checkNonNull} = wasmEvalText(`(module
+  (func (export "checkNonNull") (param externref) (result (ref extern))
+    local.get 0
+    ref.as_non_null
+  )
+)`).exports;
+
+assertErrorMessage(() => checkNonNull(null), WebAssembly.RuntimeError, /dereferencing null pointer/);
+for (let val of WasmNonNullExternrefValues) {
+  assertEq(checkNonNull(val), val, `is non-null`);
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/binary.js b/js/src/jit-test/tests/wasm/function-references/binary.js
new file mode 100644
index 0000000000..91cf807dc4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/binary.js
@@ -0,0 +1,52 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+load(libdir + "wasm-binary.js");
+
+const v2vSig = {args:[], ret:VoidCode};
+const v2vSigSection = sigSection([v2vSig]);
+
+function checkInvalid(binary, errorMessage) {
+    assertErrorMessage(() => new WebAssembly.Module(binary),
+        WebAssembly.CompileError,
+        errorMessage);
+}
+
+// The immediate of ref.null is a heap type, not a general reference type
+
+const invalidRefNullHeapBody = moduleWithSections([
+    v2vSigSection,
+    declSection([0]),
+    bodySection([
+        funcBody({locals:[], body:[
+            RefNullCode,
+            OptRefCode,
+            AnyFuncCode,
+            DropCode,
+        ]})
+    ])
+]);
+checkInvalid(invalidRefNullHeapBody, /invalid heap type/);
+
+const invalidRefNullHeapElem = moduleWithSections([
+    generalElemSection([
+        {
+            flag: PassiveElemExpr,
+            typeCode: AnyFuncCode,
+            elems: [
+                [RefNullCode, OptRefCode, AnyFuncCode, EndCode]
+            ]
+        }
+    ])
+]);
+checkInvalid(invalidRefNullHeapElem, /invalid heap type/);
+
+const invalidRefNullHeapGlobal = moduleWithSections([
+    globalSection([
+        {
+            valType: AnyFuncCode,
+            flag: 0,
+            initExpr: [RefNullCode, OptRefCode, AnyFuncCode, EndCode]
+        }
+    ])
+]);
+checkInvalid(invalidRefNullHeapGlobal, /invalid heap type/);
diff --git a/js/src/jit-test/tests/wasm/function-references/br-non-null.js b/js/src/jit-test/tests/wasm/function-references/br-non-null.js
new file mode 100644
index 0000000000..371cdaa40a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/br-non-null.js
@@ -0,0 +1,76 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+// br_on_non_null from constant
+wasmValidateText(`(module
+  (func
+    block (result (ref extern))
+      ref.null extern
+      br_on_non_null 0
+      return
+    end
+    drop
+  )
+)`);
+
+// br_on_non_null from parameter
+wasmValidateText(`(module
+  (func (param externref) (result (ref extern))
+    local.get 0
+    br_on_non_null 0
+    unreachable
+  )
+)`);
+
+// br_on_null with multiple results
+wasmValidateText(`(module
+  (func (param (ref null extern) (ref extern)) (result i32 i32 i32 (ref extern))
+    i32.const 0
+    i32.const 1
+    i32.const 2
+    local.get 0
+    br_on_non_null 0
+    local.get 1
+  )
+)`);
+
+// no block type
+wasmFailValidateText(`(module
+  (func
+    block
+      ref.null extern
+      br_on_non_null 0
+    end
+  )
+)`, /type mismatch: target block type expected to be \[_, ref\]/);
+
+// in dead code
+wasmValidateText(`(module
+  (type $t (func))
+  (func (result funcref)
+    ref.null $t
+    return
+    br_on_non_null 0
+  )
+)`);
+
+wasmFailValidateText(`(module
+  (func
+    return
+    br_on_non_null 0
+  )
+)`, /type mismatch: target block type expected to be \[_, ref\]/);
+
+// Test the branch takes the correct path and results are passed correctly
+let {ifNull} = wasmEvalText(`(module
+  (func (export "ifNull") (param externref externref) (result externref)
+    local.get 0
+    br_on_non_null 0
+    local.get 1
+  )
+)`).exports;
+
+const DefaultTestVal = "default!test";
+assertEq(ifNull(null, DefaultTestVal), DefaultTestVal);
+for (let val of WasmNonNullExternrefValues) {
+  assertEq(ifNull(val, DefaultTestVal), val);
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/br-null.js b/js/src/jit-test/tests/wasm/function-references/br-null.js
new file mode 100644
index 0000000000..26d1013de2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/br-null.js
@@ -0,0 +1,58 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+// br_on_null from constant
+wasmValidateText(`(module
+  (func
+    ref.null extern
+    br_on_null 0
+    drop
+  )
+)`);
+
+// br_on_null from parameter
+wasmValidateText(`(module
+  (func (param externref)
+    local.get 0
+    br_on_null 0
+    drop
+  )
+)`);
+
+// br_on_null with single result
+wasmValidateText(`(module
+  (func (result i32)
+    i32.const 0
+    ref.null extern
+    br_on_null 0
+    drop
+  )
+)`);
+
+// br_on_null with multiple results
+wasmValidateText(`(module
+  (func (result i32 i32 i32)
+    i32.const 0
+    i32.const 1
+    i32.const 2
+    ref.null extern
+    br_on_null 0
+    drop
+  )
+)`);
+
+// Test the branch takes the correct path and results are passed correctly
+let {isNull} = wasmEvalText(`(module
+  (func (export "isNull") (param externref) (result i32)
+    i32.const 1
+    local.get 0
+    br_on_null 0
+    drop
+    drop
+    i32.const 0
+  )
+)`).exports;
+
+assertEq(isNull(null), 1, `null is null`);
+for (let val of WasmNonNullExternrefValues) {
+  assertEq(isNull(val), 0, `${typeof(val)} is not null`);
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/call_ref.js b/js/src/jit-test/tests/wasm/function-references/call_ref.js
new file mode 100644
index 0000000000..205f5329a9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/call_ref.js
@@ -0,0 +1,100 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+let { plusOne } = wasmEvalText(`(module
+  (; forward declaration so that ref.func works ;)
+  (elem declare $plusOneRef)
+  (type $t (func (param i32) (result i32)))
+
+  (func $plusOneRef (param i32) (result i32)
+    (i32.add
+      local.get 0
+      i32.const 1)
+  )
+
+  (func (export "plusOne") (param i32) (result i32)
+    local.get 0
+    ref.func $plusOneRef
+    call_ref $t
+  )
+)`).exports;
+
+assertEq(plusOne(3), 4);
+
+// pass non-funcref type
+wasmFailValidateText(`(module
+  (type $t (func (param i32)))
+  (func (param $a i32)
+    local.get $a
+    call_ref $t
+  )
+)`, /type mismatch: expression has type i32 but expected \(ref null \d+\)/);
+
+wasmFailValidateText(`(module
+  (type $t (func (param externref)))
+  (func (param $a (ref extern))
+    local.get $a
+    call_ref $t
+  )
+)`, /type mismatch: expression has type \(ref extern\) but expected \(ref null \d+\)/);
+
+// pass (non-subtype of) funcref
+wasmFailValidateText(`(module
+  (type $t (func (param i32) (result i32)))
+  (func (param funcref)
+    local.get 0
+    call_ref $t
+  )
+)`, /type mismatch: expression has type funcref but expected \(ref null \d+\)/);  
+  
+// signature mismatch
+wasmFailValidateText(`(module
+  (type $t (func (param i32) (result i32)))
+  (elem declare $plusOneRef)
+  (func $plusOneRef (param f32) (result f32)
+    (f32.add
+      local.get 0
+      f32.const 1.0)
+  )
+
+  (func (export "plusOne") (param i32) (result i32)
+    local.get 0
+    ref.func $plusOneRef
+    call_ref $t
+  )
+)`, /type mismatch: expression has type \(ref \d+\) but expected \(ref null \d+\)/);
+
+// Cross-instance calls
+let { loadInt } = wasmEvalText(`(module
+  (memory 1 1)
+  (data (i32.const 0) "\\04\\00\\00\\00")
+  (func (export "loadInt") (result i32)
+    i32.const 0
+    i32.load offset=0
+  )
+)`).exports;
+
+let { callLoadInt } = wasmEvalText(`(module
+  (type $t (func (result i32)))
+  (elem declare 0)
+  (import "" "loadInt" (func (result i32)))
+  (func (export "callLoadInt") (result i32)
+    ref.func 0
+    call_ref $t
+  )
+)`, {"": { loadInt, }}).exports;
+
+assertEq(loadInt(), 4);
+assertEq(callLoadInt(), 4);
+
+// Null call.
+assertErrorMessage(function() {
+  let { nullCall } = wasmEvalText(`(module
+    (type $t (func (param i32) (result i32)))
+    (func (export "nullCall") (param i32) (result i32)
+      local.get 0
+      ref.null $t
+      call_ref $t
+    )
+  )`).exports;
+  nullCall(3);
+}, WebAssembly.RuntimeError, /dereferencing null pointer/);
diff --git a/js/src/jit-test/tests/wasm/function-references/directives.txt b/js/src/jit-test/tests/wasm/function-references/directives.txt
new file mode 100644
index 0000000000..f7d2135421
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing --wasm-function-references; test-also=--wasm-compiler=baseline --wasm-function-references; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/function-references/disabled.js b/js/src/jit-test/tests/wasm/function-references/disabled.js
new file mode 100644
index 0000000000..70a66a937d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/disabled.js
@@ -0,0 +1,17 @@
+// |jit-test| skip-if: wasmFunctionReferencesEnabled()
+
+const { CompileError, validate } = WebAssembly;
+
+const UNRECOGNIZED_OPCODE_OR_BAD_TYPE = /unrecognized opcode|bad type|\(ref T\) types not enabled/;
+
+let simpleTests = [
+    `(module (func (param (ref 0)) (unreachable)))`,
+];
+
+// Test that use of function-references fails when function-references is disabled.
+
+for (let src of simpleTests) {
+    let bin = wasmTextToBinary(src);
+    assertEq(validate(bin), false);
+    wasmCompilationShouldFail(bin, UNRECOGNIZED_OPCODE_OR_BAD_TYPE);
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/nnl-test.js b/js/src/jit-test/tests/wasm/function-references/nnl-test.js
new file mode 100644
index 0000000000..0036a7b30d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/nnl-test.js
@@ -0,0 +1,172 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+// Generates combinations of different block types and operations for
+// non-defaultable locals (local.set / .tee / .get).
+// See the function references specification on the updated algorithm
+// for validating non-null references in locals.
+
+const KINDS = [
+  "block",
+  "loop",
+  "try",
+  "catch",
+  "if",
+  "else",
+]
+const INITIALIZED = [
+  "nowhere",
+  "outer",
+  "inner",
+  "outer-tee",
+  "inner-tee",
+];
+const USED = [
+  "outer",
+  "inner",
+  "after-inner",
+  "after-outer",
+];
+
+function generateBlock(kind, contents) {
+  switch (kind) {
+    case "block": {
+      return `block\n${contents}end\n`
+    }
+    case "loop": {
+      return `loop\n${contents}end\n`
+    }
+    case "try": {
+      return `try\n${contents}end\n`
+    }
+    case "catch": {
+      return `try\ncatch_all\n${contents}end\n`
+    }
+    case "if": {
+      return `i32.const 0\nif\n${contents}end\n`
+    }
+    case "else": {
+      return `i32.const 0\nif\nelse\n${contents}end\n`
+    }
+  }
+}
+
+// Generate a variation of the module below:
+//
+// (func
+//  (block
+//    $outer
+//    (block
+//      $inner
+//    )
+//    $after-inner
+//  )
+//  $after-outer
+// )
+//
+// Where a local is used and initialized at different points depending on the
+// parameters. The block kinds of the inner and outer block may also be
+// customized.
+function generateModule(outerBlockKind, innerBlockKind, initializedWhere, usedWhere) {
+  const INITIALIZE_STMT = '(local.set 0 ref.func 0)\n';
+  const INITIALIZE_STMT2 = '(drop (local.tee 0 ref.func 0))\n';
+  const USE_STMT = '(drop local.get 0)\n';
+
+  // inner block
+  let innerBlockContents = '';
+  if (initializedWhere === 'inner') {
+    innerBlockContents += INITIALIZE_STMT;
+  } else if (initializedWhere === 'inner-tee') {
+    innerBlockContents += INITIALIZE_STMT2;
+  }
+  if (usedWhere === 'inner') {
+    innerBlockContents += USE_STMT;
+  }
+  let innerBlock = generateBlock(innerBlockKind, innerBlockContents);
+
+  // outer block
+  let outerBlockContents = '';
+  if (initializedWhere === 'outer') {
+    outerBlockContents += INITIALIZE_STMT;
+  } else if (initializedWhere === 'outer-tee') {
+    outerBlockContents += INITIALIZE_STMT2;
+  }
+  if (usedWhere === 'outer') {
+    outerBlockContents += USE_STMT;
+  }
+  outerBlockContents += innerBlock;
+  if (usedWhere === 'after-inner') {
+    outerBlockContents += USE_STMT;
+  }
+  let outerBlock = generateBlock(outerBlockKind, outerBlockContents);
+
+  // after outer block
+  let afterOuterBlock = '';
+  if (usedWhere === 'after-outer') {
+    afterOuterBlock += USE_STMT;
+  }
+
+  return `(module
+  (type $t (func))
+  (func (export "test")
+    (local (ref $t))
+${outerBlock}${afterOuterBlock}  )
+)`;
+}
+
+const LOGGING = false;
+
+for (let outer of KINDS) {
+  for (let inner of KINDS) {
+    for (let initialized of INITIALIZED) {
+      for (let used of USED) {
+        let text = generateModule(outer, inner, initialized, used);
+
+        let expectPass;
+        switch (initialized) {
+          case "outer":
+          case "outer-tee": {
+            // Defining the local in the outer block makes it valid
+            // in the outer block, the inner block, and after the
+            // inner block
+            expectPass = used !== "after-outer";
+            break;
+          }
+          case "inner":
+          case "inner-tee": {
+            // Defining the local in the inner block makes it valid
+            // in the inner block
+            //
+            // NOTE: an extension to typing could make this valid
+            // after the inner block in some cases
+            expectPass = used === "inner";
+            break;
+          }
+          case "nowhere": {
+            // Not defining the local makes it always invalid to
+            // use
+            expectPass = false;
+            break;
+          }
+        }
+
+        if (LOGGING) {
+          console.log();
+          console.log(`TEST: outer=${outer}, inner=${inner}, initialized=${initialized}, used=${used}`);
+          console.log(expectPass ? "EXPECT PASS" : "EXPECT FAIL");
+          console.log(text);
+        }
+
+        let binary = wasmTextToBinary(text);
+        assertEq(WebAssembly.validate(binary), expectPass);
+        if (!expectPass) {
+          // Check if the error message is right.
+          try {
+            new WebAssembly.Module(binary);
+          } catch (ex) {
+            assertEq(true, /local\.get read from unset local/.test(ex.message));
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/non-nullable-table.js b/js/src/jit-test/tests/wasm/function-references/non-nullable-table.js
new file mode 100644
index 0000000000..97ab04713c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/non-nullable-table.js
@@ -0,0 +1,79 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+// non-null table initialization
+var { get1, get2, get3, get4 } = wasmEvalText(`(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))
+  (table $t4 10 (ref func) (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)))
+  (func (export "get4") (result funcref) (table.get $t4 (i32.const 5)))
+)`).exports;
+assertEq(get1(), null);
+assertEq(get2() != null, true);
+assertEq(get3() != null, true);
+assertEq(get4() != null, true);
+
+const sampleWasmFunction = get2();
+sampleWasmFunction();
+
+// Invalid initializers
+for (let i of [
+  `(table $t1 10 (ref $dummy) (ref.func $dummy1))`,
+  `(table $t2 5 10 (ref func))`,
+  `(table $t3 10 10 (ref func) (ref.null $dummy1))`,
+  `(table $t4 10 (ref $dummy))`,
+  '(table $t5 1 (ref $dummy) (ref.null $dummy))',
+]) {
+  wasmFailValidateText(`(module
+    (type $dummy (func))
+    (type $dummy1 (func (param i32)))
+    (func $dummy1 (param i32))
+
+    ${i}
+  )`, /(type mismatch|table with non-nullable references requires initializer)/);
+}
+
+var t1 = new WebAssembly.Table({initial: 10, element: {ref: 'func', nullable: false }}, sampleWasmFunction);
+assertEq(t1.get(2) != null, true);
+assertThrows(() => {
+  new WebAssembly.Table({initial: 10, element: {ref: 'func', nullable: false }});
+});
+assertThrows(() => {
+  new WebAssembly.Table({initial: 10, element: {ref: 'func', nullable: false }}, null);
+});
+
+var t2 = new WebAssembly.Table({initial: 6, maximum: 20, element: {ref: 'extern', nullable: false }}, {foo: "bar"});
+assertEq(t2.get(1).foo, "bar");
+assertThrows(() => { t2.get(7) });
+assertThrows(() => { t2.grow(9, null) });
+t2.grow(8, {t: "test"});
+assertEq(t2.get(3).foo, "bar");
+assertEq(t2.get(7).t, "test");
+assertThrows(() => {
+  new WebAssembly.Table({initial: 10, element: {ref: 'extern', nullable: false }}, null);
+});
+
+// Fail because tables come before globals in the binary format, so tables
+// cannot refer to globals.
+wasmFailValidateText(`(module
+  (global $g1 externref)
+  (table 10 externref (global.get $g1))
+)`, /global.get index out of range/);
+
+function assertThrows(f) {
+  var ok = false;
+  try {
+      f();
+  } catch (exc) {
+      ok = true;
+  }
+  if (!ok)
+      throw new TypeError("Assertion failed: " + f + " did not throw as expected");
+}
diff --git a/js/src/jit-test/tests/wasm/function-references/non-nullable.js b/js/src/jit-test/tests/wasm/function-references/non-nullable.js
new file mode 100644
index 0000000000..b8fd20fd83
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/non-nullable.js
@@ -0,0 +1,176 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+// non-null values are subtype of null values
+wasmValidateText(`(module
+  (func (param $a (ref extern))
+    local.get $a
+    (block (param (ref null extern))
+      drop
+    )
+  )
+)`);
+
+// null values are not subtype of non-null values
+wasmFailValidateText(`(module
+  (func (param $a (ref null extern))
+    local.get $a
+    (block (param (ref extern))
+      drop
+    )
+  )
+)`, /expression has type externref but expected \(ref extern\)/);
+
+// can have non-defaultable local, but not use/get if unset.
+wasmValidateText(`(module
+  (func (local (ref extern)))
+)`);
+wasmFailValidateText(`(module
+  (func (local (ref extern))
+    local.get 0
+    drop
+  )
+)`, /local\.get read from unset local/);
+wasmFailValidateText(`(module
+  (func
+    (local (ref extern))
+    unreachable
+    block
+      local.get 0
+      drop
+    end
+  )
+)`, /local\.get read from unset local/);
+wasmFailValidateText(`(module
+  (func (param funcref) (result funcref) (local (ref func))
+    block
+      local.get 0
+      ref.as_non_null
+      local.set 1
+    end
+    local.get 1
+  )
+)`, /local\.get read from unset local/);
+wasmValidateText(`(module
+  (func (param $r (ref extern))
+    (local $var (ref extern))
+    local.get $r
+    ref.as_non_null
+    local.set $var
+    block block block
+    local.get $var
+    drop
+    end end end
+  )
+  (func
+    (param (ref null func) (ref null func) (ref func))
+    (result funcref)
+    (local (ref func) i32 (ref func) (ref null func))
+    local.get 0
+    ref.as_non_null
+    local.tee 3
+    block
+      local.get 6
+      ref.as_non_null
+      local.set 5 
+    end
+    local.get 2
+    drop
+    local.tee 5
+  )  
+)`);
+wasmFailValidateText(`(module
+  (elem declare 0)
+  (func
+    (local (ref func))
+    i32.const 0
+    if
+      ref.func 0
+      local.set 0
+    else
+      local.get 0
+      drop
+    end
+  )
+)`, /local\.get read from unset local/);
+wasmValidateText(`(module
+  (elem declare 0)
+  (func (result funcref)
+    (local (ref func) (ref func))
+    i32.const 0
+    if (result funcref)
+      ref.func 0
+      local.set 0
+      local.get 0
+    else
+      ref.func 0
+      local.tee 1
+      local.get 1
+      drop
+    end
+  )
+)`);
+
+// exported funcs can't take null in non-nullable params
+let {a} = wasmEvalText(`(module
+  (func (export "a") (param (ref extern)))
+)`).exports;
+assertErrorMessage(() => a(null), TypeError, /cannot pass null to non-nullable/);
+for (let val of WasmNonNullExternrefValues) {
+  a(val);
+}
+
+// imported funcs can't return null in non-nullable results
+function returnNull() {
+  return null;
+}
+function returnMultiNullReg() {
+  return [null, null];
+}
+function returnMultiNullStack() {
+  return [1, 2, 3, 4, 5, 6, 7, 8, null];
+}
+let {runNull, runMultiNullReg, runMultiNullStack} = wasmEvalText(`(module
+  (func $returnNull (import "" "returnNull") (result (ref extern)))
+  (func $returnMultiNullReg (import "" "returnMultiNullReg") (result (ref extern) (ref extern)))
+  (func $returnMultiNullStack (import "" "returnMultiNullStack") (result (ref extern) (ref extern) (ref extern) (ref extern) (ref extern) (ref extern) (ref extern) (ref extern) (ref extern)))
+  (func (export "runNull")
+    call $returnNull
+    unreachable
+  )
+  (func (export "runMultiNullReg")
+    call $returnMultiNullReg
+    unreachable
+  )
+  (func (export "runMultiNullStack")
+    call $returnMultiNullStack
+    unreachable
+  )
+)`, { "": { returnNull, returnMultiNullReg, returnMultiNullStack } }).exports;
+assertErrorMessage(() => runNull(), TypeError, /cannot pass null to non-nullable/);
+assertErrorMessage(() => runMultiNullReg(), TypeError, /cannot pass null to non-nullable/);
+assertErrorMessage(() => runMultiNullStack(), TypeError, /cannot pass null to non-nullable/);
+
+{
+  // can have non-nullable globals
+  wasmEvalText(`(module
+    (func $f)
+    (elem declare $f)
+    (global (ref func) ref.func $f)
+  )`);
+}
+
+// cannot have non-nullable tables without initializer
+wasmFailValidateText(`(module
+  (table (ref extern) (elem))
+)`, /table with non-nullable references requires initializer/);
+
+// Testing internal wasmLosslessInvoke to pass non-nullable as params and arguments.
+let {t} = wasmEvalText(`(module
+  (func (export "t") (param (ref extern)) (result (ref extern))
+    (local (ref extern))
+    (local.set 1 (local.get 0))
+    (local.get 1)
+  )
+)`).exports;
+const ret = wasmLosslessInvoke(t, {test: 1});
+assertEq(ret.value.test, 1);
diff --git a/js/src/jit-test/tests/wasm/function-references/reftype-parse.js b/js/src/jit-test/tests/wasm/function-references/reftype-parse.js
new file mode 100644
index 0000000000..643f753ec8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/function-references/reftype-parse.js
@@ -0,0 +1,51 @@
+// |jit-test| skip-if: !wasmFunctionReferencesEnabled()
+
+// RefType/ValueType as a simple string
+const t01 = new WebAssembly.Table({element: 'funcref', initial: 3});
+const t02 = new WebAssembly.Table({element: 'externref', initial: 8});
+const g01 = new WebAssembly.Global({value: 'funcref', mutable: true}, null);
+const g02 = new WebAssembly.Global({value: 'externref', mutable: true}, null);
+
+// Specify ToString() equivalents
+const t05 = new WebAssembly.Table({element: {toString() { return 'funcref' },}, initial: 11});
+const t06 = new WebAssembly.Table({element: ['externref'], initial: 7});
+
+assertErrorMessage(
+    () => new WebAssembly.Table({element: 'foo', initial: 1}),
+    TypeError, /bad value type/);
+assertErrorMessage(
+    () => new WebAssembly.Table({element: true, initial: 1}),
+    TypeError, /bad value type/);
+    
+// RefType/ValueType can be specified as an {ref: 'func', ...} object
+const t11 = new WebAssembly.Table({element: {ref: 'func', nullable: true}, initial: 3});
+const t12 = new WebAssembly.Table({element: {ref: 'extern', nullable: true}, initial: 3});
+const t13 = new WebAssembly.Table({element: {ref: 'extern', nullable: false}, initial: 3}, {});
+
+assertErrorMessage(
+    () => new WebAssembly.Table({element: {ref: 'func', nullable: false}, initial: 1}, null),
+    TypeError, /cannot pass null to non-nullable WebAssembly reference/);
+assertErrorMessage(
+    () => new WebAssembly.Table({element: {ref: 'extern', nullable: false}, initial: 1}, null),
+    TypeError, /cannot pass null to non-nullable WebAssembly reference/);
+
+assertErrorMessage(
+    () => new WebAssembly.Table({element: {ref: 'bar', nullable: true}, initial: 1}),
+    TypeError, /bad value type/);
+
+const g11 = new WebAssembly.Global({value: {ref: 'func', nullable: true}, mutable: true});
+const g12 = new WebAssembly.Global({value: {ref: 'extern', nullable: true}, mutable: true});
+const g13 = new WebAssembly.Global({value: {ref: 'extern', nullable: false}, mutable: true}, {});
+const g14 = new WebAssembly.Global({value: {ref: 'extern', nullable: false}, mutable: true});
+const g15 = new WebAssembly.Global({value: {ref: 'extern', nullable: false}, mutable: true}, void 0);
+
+assertErrorMessage(
+    () => new WebAssembly.Global({value: {ref: 'func', nullable: false}, mutable: true}),
+    TypeError, /cannot pass null to non-nullable WebAssembly reference/);
+assertErrorMessage(
+    () => new WebAssembly.Global({value: {ref: 'extern', nullable: false}, mutable: true}, null),
+    TypeError, /cannot pass null to non-nullable WebAssembly reference/);
+    
+assertErrorMessage(
+    () => new WebAssembly.Global({value: {ref: 'bar', nullable: true}, mutable: true}),
+    TypeError, /bad value type/);
diff --git a/js/src/jit-test/tests/wasm/gc/TypedObject.js b/js/src/jit-test/tests/wasm/gc/TypedObject.js
new file mode 100644
index 0000000000..93eae428c4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/TypedObject.js
@@ -0,0 +1,121 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// We can read the object fields from JS
+
+{
+    let ins = wasmEvalText(`(module
+                             (type $p (struct (field f64) (field (mut i32))))
+
+                             (func (export "mkp") (result eqref)
+                              (struct.new $p (f64.const 1.5) (i32.const 33))))`).exports;
+
+    let p = ins.mkp();
+    assertEq(p[0], 1.5);
+    assertEq(p[1], 33);
+    assertEq(p[2], undefined);
+}
+
+// Writing an immutable field from JS throws.
+
+{
+    let ins = wasmEvalText(`(module
+                             (type $p (struct (field f64)))
+
+                             (func (export "mkp") (result eqref)
+                              (struct.new $p (f64.const 1.5))))`).exports;
+
+    let p = ins.mkp();
+    assertErrorMessage(() => p[0] = 5.7,
+                       Error,
+                       /setting immutable field/);
+}
+
+// MVA v1 restriction: structs have no prototype
+
+{
+    let ins = wasmEvalText(`(module
+                             (type $q (struct (field (mut f64))))
+                             (type $p (struct (field (mut (ref null $q)))))
+
+                             (type $r (struct (field (mut eqref))))
+
+                             (func (export "mkp") (result eqref)
+                              (struct.new $p (ref.null $q)))
+
+                             (func (export "mkr") (result eqref)
+                              (struct.new $r (ref.null eq))))`).exports;
+
+    assertEq(Object.getPrototypeOf(ins.mkp()), null);
+    assertEq(Object.getPrototypeOf(ins.mkr()), null);
+}
+
+// MVA v1 restriction: all fields are immutable
+
+{
+    let ins = wasmEvalText(`(module
+                             (type $q (struct (field (mut f64))))
+                             (type $p (struct (field (mut (ref null $q))) (field (mut eqref))))
+
+                             (func (export "mkq") (result eqref)
+                              (struct.new $q (f64.const 1.5)))
+
+                             (func (export "mkp") (result eqref)
+                              (struct.new $p (ref.null $q) (ref.null eq))))`).exports;
+    let q = ins.mkq();
+    assertEq(typeof q, "object");
+    assertEq(q[0], 1.5);
+
+    let p = ins.mkp();
+    assertEq(typeof p, "object");
+    assertEq(p[0], null);
+
+    assertErrorMessage(() => { p[0] = q },
+                       Error,
+                       /setting immutable field/);
+
+    assertErrorMessage(() => { p[1] = q },
+                       Error,
+                       /setting immutable field/);
+}
+
+// MVA v1 restriction: structs that expose i64 fields make those fields
+// immutable from JS, and the structs are not constructible from JS.
+
+{
+    let ins = wasmEvalText(`(module
+                             (type $p (struct (field (mut i64))))
+                             (func (export "mkp") (result eqref)
+                              (struct.new $p (i64.const 0x1234567887654321))))`).exports;
+
+    let p = ins.mkp();
+    assertEq(typeof p, "object");
+    assertEq(p[0], 0x1234567887654321n)
+
+    assertErrorMessage(() => { p[0] = 0 },
+                       Error,
+                       /setting immutable field/);
+}
+
+// A consequence of the current mapping of i64 as two i32 fields is that we run
+// a risk of struct.narrow not recognizing the difference.  So check this.
+
+{
+    let ins = wasmEvalText(
+        `(module
+          (type $p (struct (field i64)))
+          (type $q (struct (field i32) (field i32)))
+          (func $f (param eqref) (result i32)
+           local.get 0
+           ref.test (ref $q)
+          )
+          (func $g (param eqref) (result i32)
+           local.get 0
+           ref.test (ref $p)
+          )
+          (func (export "t1") (result i32)
+           (call $f (struct.new $p (i64.const 0))))
+          (func (export "t2") (result i32)
+           (call $g (struct.new $q (i32.const 0) (i32.const 0)))))`).exports;
+    assertEq(ins.t1(), 0);
+    assertEq(ins.t2(), 0);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/arrays.js b/js/src/jit-test/tests/wasm/gc/arrays.js
new file mode 100644
index 0000000000..44770b85ea
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/arrays.js
@@ -0,0 +1,1104 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Test array instructions on different valtypes
+
+const GENERAL_TESTS = [
+  [
+    'i32',
+    0,
+    0xce,
+  ], [
+    'i64',
+    0n,
+    0xabcdefn,
+  ], [
+    'f32',
+    0,
+    13.5,
+  ], [
+    'f64',
+    0,
+    13.5,
+  ], [
+    'externref',
+    null,
+    'hello',
+  ],
+];
+
+for (let [valtype, def, nondef] of GENERAL_TESTS) {
+  let {create, createDefault, get, set, len} = wasmEvalText(`(module
+    (type $a (array (mut ${valtype})))
+
+    (; new T[0] = { 1... }  ;)
+    (func (export "create") (param i32 ${valtype}) (result eqref)
+      local.get 1
+      local.get 0
+      array.new $a
+    )
+
+    (; new T[0] ;)
+    (func (export "createDefault") (param i32) (result eqref)
+      local.get 0
+      array.new_default $a
+    )
+
+    (; 0[1] ;)
+    (func (export "get") (param eqref i32) (result ${valtype})
+      local.get 0
+      ref.cast (ref null $a)
+      local.get 1
+      array.get $a
+    )
+
+    (; 0[1] = 2 ;)
+    (func (export "set") (param eqref i32 ${valtype})
+      local.get 0
+      ref.cast (ref null $a)
+      local.get 1
+      local.get 2
+      array.set $a
+    )
+
+    (; len(a) ;)
+    (func (export "len") (param eqref) (result i32)
+      local.get 0
+      ref.cast (ref null $a)
+      array.len
+    )
+  )`).exports;
+
+  function checkArray(array, length, init, setval) {
+    // Check length
+    assertEq(len(array), length);
+    assertEq(array.length, length);
+
+    // Check init value
+    for (let i = 0; i < length; i++) {
+      assertEq(array[i], init);
+      assertEq(get(array, i), init);
+    }
+
+    // Set every element to setval
+    for (let i = 0; i < length; i++) {
+      set(array, i, setval);
+
+      // Check there is no overwrite
+      for (let j = i + 1; j < length; j++) {
+        assertEq(array[j], init);
+        assertEq(get(array, j), init);
+      }
+    }
+
+    // Check out of bounds conditions
+    for (let loc of [-1, length, length + 1]) {
+      assertErrorMessage(() => {
+        get(array, loc);
+      }, WebAssembly.RuntimeError, /out of bounds/);
+      assertErrorMessage(() => {
+        set(array, loc, setval);
+      }, WebAssembly.RuntimeError, /out of bounds/);
+    }
+  }
+
+  for (let arrayLength = 0; arrayLength < 5; arrayLength++) {
+    checkArray(createDefault(arrayLength), arrayLength, def, nondef);
+    checkArray(create(arrayLength, nondef), arrayLength, nondef, def);
+  }
+}
+
+// Check packed array reads and writes
+
+for (let [fieldtype, max] of [
+  [
+    'i8',
+    0xff,
+  ], [
+    'i16',
+    0xffff,
+  ]
+]) {
+  let {create, getS, getU, set} = wasmEvalText(`(module
+    (type $a (array (mut ${fieldtype})))
+
+    (; new T[0] = { 1... }  ;)
+    (func (export "create") (param i32 i32) (result eqref)
+      local.get 1
+      local.get 0
+      array.new $a
+    )
+
+    (; 0[1] ;)
+    (func (export "getS") (param eqref i32) (result i32)
+      local.get 0
+      ref.cast (ref null $a)
+      local.get 1
+      array.get_s $a
+    )
+
+    (; 0[1] ;)
+    (func (export "getU") (param eqref i32) (result i32)
+      local.get 0
+      ref.cast (ref null $a)
+      local.get 1
+      array.get_u $a
+    )
+
+    (; 0[1] = 2 ;)
+    (func (export "set") (param eqref i32 i32)
+      local.get 0
+      ref.cast (ref null $a)
+      local.get 1
+      local.get 2
+      array.set $a
+    )
+  )`).exports;
+
+  // Check zero and sign extension
+  let a = create(1, 0);
+  set(a, 0, max);
+  assertEq(getS(a, 0), -1);
+  assertEq(getU(a, 0), max);
+
+  // JS-API defaults to sign extension
+  assertEq(a[0], getS(a, 0));
+
+  // Check array.new truncates init value
+  assertEq(create(1, max + 1)[0], 0);
+
+  // Check array.set truncates
+  let b = create(1, 0);
+  set(b, 0, max + 1);
+  assertEq(getU(b, 0), 0);
+
+  // Check no overwrite on set
+  let c = create(2, 0);
+  set(c, 0, max << 4);
+  assertEq(getU(c, 0), (max << 4) & max);
+  assertEq(getU(c, 1), 0);
+}
+
+// Check arrays must be mutable to mutate
+
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array i32))
+    (func
+      (array.set $a
+        (array.new $a
+          i32.const 0xff
+          i32.const 10)
+        i32.const 0
+        i32.const 0
+      )
+    )
+)
+`), WebAssembly.CompileError, /array is not mutable/);
+
+// Check operations trap on null
+
+assertErrorMessage(() => {
+  wasmEvalText(`(module
+    (type $a (array (mut i32)))
+    (func
+      ref.null $a
+      i32.const 0
+      array.get $a
+      drop
+    )
+    (start 0)
+  )`);
+}, WebAssembly.RuntimeError, /null/);
+
+assertErrorMessage(() => {
+  wasmEvalText(`(module
+    (type $a (array (mut i32)))
+    (func
+      ref.null $a
+      i32.const 0
+      i32.const 0
+      array.set $a
+    )
+    (start 0)
+  )`);
+}, WebAssembly.RuntimeError, /null/);
+
+assertErrorMessage(() => {
+  wasmEvalText(`(module
+    (type $a (array (mut i32)))
+    (func
+      ref.null $a
+      array.len
+      drop
+    )
+    (start 0)
+  )`);
+}, WebAssembly.RuntimeError, /null/);
+
+// Check an extension postfix is present iff the element is packed
+
+for ([fieldtype, packed] of [
+  ['i8', true],
+  ['i16', true],
+  ['i32', false],
+  ['i64', false],
+  ['f32', false],
+  ['f64', false],
+]) {
+  let extensionModule = `(module
+      (type $a (array ${fieldtype}))
+      (func
+        ref.null $a
+        i32.const 0
+        array.get_s $a
+        drop
+      )
+      (func
+        ref.null $a
+        i32.const 0
+        array.get_u $a
+        drop
+      )
+    )`;
+  let noExtensionModule = `(module
+      (type $a (array ${fieldtype}))
+      (func
+        ref.null $a
+        i32.const 0
+        array.get $a
+        drop
+      )
+    )`;
+
+  if (packed) {
+    wasmValidateText(extensionModule);
+    wasmFailValidateText(noExtensionModule, /must specify signedness/);
+  } else {
+    wasmFailValidateText(extensionModule, /must not specify signedness/);
+    wasmValidateText(noExtensionModule);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// array.new_fixed
+/*
+  validation:
+    array-type imm-operand needs to be "in range"
+    array-type imm-operand must refer to an array type
+    operands (on stack) must all match ("be compatible with") the array elem
+      type
+    number of operands (on stack) must not be less than the num-of-elems
+      imm-operand
+    zero elements doesn't fail compilation
+    reftypes elements doesn't fail compilation
+    trying to create a 1-billion-element array fails gracefully
+  run:
+    resulting 4-element array is as expected
+    resulting zero-element array is as expected
+    resulting 30-element array is as expected
+*/
+
+// validation: array-type imm-operand needs to be "in range"
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array i8))
+    (func (result eqref)
+      i32.const 66
+      i32.const 77
+      array.new_fixed 2 2  ;; type index 2 is the first invalid one
+    )
+)
+`), WebAssembly.CompileError, /type index out of range/);
+
+// validation: array-type imm-operand must refer to an array type
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (func (param f64) (result f64)))
+    (func (result eqref)
+      i32.const 66
+      i32.const 77
+      array.new_fixed $a 2
+    )
+)
+`), WebAssembly.CompileError, /not an array type/);
+
+// validation: operands (on stack) must all match ("be compatible with")
+//   the array elem type
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array i32))
+    (func (result eqref)
+      f32.const 66.6
+      f64.const 77.7
+      array.new_fixed $a 2
+    )
+)
+`), WebAssembly.CompileError, /expression has type f64 but expected i32/);
+
+// validation: number of operands (on stack) must not be less than the
+//   num-of-elems imm-operand
+assertNoWarning(() => wasmEvalText(`(module
+    (type $a (array f32))
+    (func
+      f64.const 66.6  ;; we won't put this in the array
+      f32.const 77.7
+      f32.const 88.8
+      array.new_fixed $a 2  ;; use up 88.8 and 77.7 and replace with array
+      drop            ;; dump the array
+      f64.const 99.9
+      f64.mul         ;; check the 66.6 value is still on the stack
+      drop            ;; now should be empty
+    )
+)
+`));
+// (more)
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array i64))
+    (func (param i64) (result eqref)
+       local.get 0
+       array.new_fixed $a 2
+    )
+)
+`), WebAssembly.CompileError, /popping value from empty stack/);
+
+// validation: zero elements doesn't fail compilation
+assertNoWarning(() => wasmEvalText(`(module
+    (type $a (array i32))
+    (func (result eqref)
+       array.new_fixed $a 0
+    )
+)
+`));
+
+// validation: reftyped elements doesn't fail compilation
+assertNoWarning(() => wasmEvalText(`(module
+    (type $a (array eqref))
+    (func (param eqref) (result eqref)
+       local.get 0
+       array.new_fixed $a 1
+    )
+)
+`));
+
+// validation: trying to create a 1-billion-element array fails gracefully
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array f32))
+    (func (export "newFixed") (result eqref)
+            f32.const 1337.0
+            f32.const 4771.0
+            array.new_fixed $a 1000000000
+    )
+)
+`), WebAssembly.CompileError, /popping value from empty stack/);
+
+// run: resulting 4-element array is as expected
+{
+    let { newFixed } = wasmEvalText(`(module
+        (type $a (array i8))
+        (func (export "newFixed") (result eqref)
+                i32.const 66
+                i32.const 77
+                i32.const 88
+                i32.const 99
+                array.new_fixed $a 4
+        )
+        )`).exports;
+    let a = newFixed();
+    assertEq(a.length, 4);
+    assertEq(a[0], 66);
+    assertEq(a[1], 77);
+    assertEq(a[2], 88);
+    assertEq(a[3], 99);
+}
+
+// run: resulting zero-element array is as expected
+{
+    let { newFixed } = wasmEvalText(`(module
+        (type $a (array i16))
+        (func (export "newFixed") (result eqref)
+                array.new_fixed $a 0
+        )
+        )`).exports;
+    let a = newFixed();
+    assertEq(a.length, 0);
+}
+
+// run: resulting 30-element array is as expected
+{
+    let { newFixed } = wasmEvalText(`(module
+        (type $a (array i16))
+        (func (export "newFixed") (result eqref)
+                i32.const 1
+                i32.const 2
+                i32.const 3
+                i32.const 4
+                i32.const 5
+                i32.const 6
+                i32.const 7
+                i32.const 8
+                i32.const 9
+                i32.const 10
+                i32.const 11
+                i32.const 12
+                i32.const 13
+                i32.const 14
+                i32.const 15
+                i32.const 16
+                i32.const 17
+                i32.const 18
+                i32.const 19
+                i32.const 20
+                i32.const 21
+                i32.const 22
+                i32.const 23
+                i32.const 24
+                i32.const 25
+                i32.const 26
+                i32.const 27
+                i32.const 28
+                i32.const 29
+                i32.const 30
+                array.new_fixed $a 30
+        )
+        )`).exports;
+    let a = newFixed();
+    assertEq(a.length, 30);
+    for (i = 0; i < 30; i++) {
+        assertEq(a[i], i + 1);
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// array.new_data
+/*
+  validation:
+    array-type imm-operand needs to be "in range"
+    array-type imm-operand must refer to an array type
+    array-type imm-operand must refer to an array of numeric elements
+    segment index must be "in range"
+  run:
+    if segment is "already used" (active, or passive that has subsequently
+      been dropped), then only a zero length array can be created
+    range to copy would require OOB read on data segment
+    resulting array is as expected
+*/
+
+// validation: array-type imm-operand needs to be "in range"
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array i8))
+        (data $d "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=4 into data ;) i32.const 4
+                array.new_data 2 $d
+        )
+)`), WebAssembly.CompileError, /type index out of range/);
+
+// validation: array-type imm-operand must refer to an array type
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (func (param f32) (result f32)))
+        (data $d "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=4 into data ;) i32.const 4
+                array.new_data $a $d
+        )
+)`), WebAssembly.CompileError, /not an array type/);
+
+// validation: array-type imm-operand must refer to an array of numeric elements
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array eqref))
+        (data $d "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=4 into data ;) i32.const 4
+                array.new_data $a $d
+        )
+)`), WebAssembly.CompileError,
+                   /element type must be i8\/i16\/i32\/i64\/f32\/f64\/v128/);
+
+// validation: segment index must be "in range"
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array i8))
+        (data $d "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=4 into data ;) i32.const 4
+                array.new_data $a 1  ;; 1 is the lowest invalid dseg index
+        )
+)`), WebAssembly.CompileError, /segment index is out of range/);
+
+// run: if segment is "already used" (active, or passive that has subsequently
+//        been dropped), then only a zero length array can be created #1
+{
+    let { newData } = wasmEvalText(`(module
+        (memory 1)
+        (type $a (array i8))
+        (data $d (offset (i32.const 0)) "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=4 into data ;) i32.const 4
+                array.new_data $a $d
+        )
+        )`).exports;
+    assertErrorMessage(() => {
+        newData();
+    },WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: if segment is "already used" (active, or passive that has subsequently
+//        been dropped), then only a zero length array can be created #2
+{
+    let { newData } = wasmEvalText(`(module
+        (memory 1)
+        (type $a (array i8))
+        (data $d (offset (i32.const 0)) "1337")
+        (func (export "newData") (result eqref)
+                (; offset=4 into data ;) i32.const 4
+                (; size=0 into data ;) i32.const 0
+                array.new_data $a $d
+        )
+        )`).exports;
+    assertErrorMessage(() => {
+        newData();
+    },WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: if segment is "already used" (active, or passive that has subsequently
+//        been dropped), then only a zero length array can be created #3
+{
+    let { newData } = wasmEvalText(`(module
+        (memory 1)
+        (type $a (array i8))
+        (data $d (offset (i32.const 0)) "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=0 into data ;) i32.const 0
+                array.new_data $a $d
+        )
+        )`).exports;
+    let arr = newData();
+    assertEq(arr.length, 0);
+}
+
+// run: range to copy would require OOB read on data segment
+{
+    let { newData } = wasmEvalText(`(module
+        (type $a (array i8))
+        (data $d "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 1
+                (; size=4 into data ;) i32.const 4
+                array.new_data $a $d
+        )
+        )`).exports;
+    assertErrorMessage(() => {
+        newData();
+    },WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: resulting array is as expected
+{
+    let { newData } = wasmEvalText(`(module
+        (type $a (array i8))
+        (data $other "\\\\9")
+        (data $d "1337")
+        (func (export "newData") (result eqref)
+                (; offset=0 into data ;) i32.const 0
+                (; size=4 into data ;) i32.const 4
+                array.new_data $a $d
+        )
+        )`).exports;
+    let arr = newData();
+    assertEq(arr.length, 4);
+    assertEq(arr[0], 48+1);
+    assertEq(arr[1], 48+3);
+    assertEq(arr[2], 48+3);
+    assertEq(arr[3], 48+7);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// array.new_elem
+/*
+  validation:
+    array-type imm-operand needs to be "in range"
+    array-type imm-operand must refer to an array type
+    array-type imm-operand must refer to an array of ref typed elements
+    destination elem type must be a supertype of src elem type
+    segment index must be "in range"
+  run:
+    if segment is "already used" (active, or passive that has subsequently
+      been dropped), then only a zero length array can be created
+    range to copy would require OOB read on elem segment
+    resulting array is as expected
+*/
+
+// validation: array-type imm-operand needs to be "in range"
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array funcref))
+        (elem $e funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem 3 $e
+        )
+)`), WebAssembly.CompileError, /type index out of range/);
+
+// validation: array-type imm-operand must refer to an array type
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (func (param i64) (result f64)))
+        (elem $e funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem $a $e
+        )
+)`), WebAssembly.CompileError, /not an array type/);
+
+// validation: array-type imm-operand must refer to an array of ref typed
+//   elements
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array f32))
+        (elem $e funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem $a $e
+        )
+)`), WebAssembly.CompileError, /element type is not a reftype/);
+
+// validation: destination elem type must be a supertype of src elem type
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array eqref))
+        (elem $e funcref $f1)
+        (func $f1 (export "f1"))
+        ;; The implied copy here is from elem-seg-of-funcrefs to
+        ;; array-of-eqrefs, which must fail, because funcref isn't
+        ;; a subtype of eqref.
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=0 into elem ;) i32.const 0
+                array.new_elem $a $e
+        )
+)`), WebAssembly.CompileError, /incompatible element types/);
+
+// validation: segment index must be "in range"
+assertErrorMessage(() => wasmEvalText(`(module
+        (type $a (array funcref))
+        (elem $e funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem $a 1  ;; 1 is the lowest invalid eseg index
+        )
+)`), WebAssembly.CompileError, /segment index is out of range/);
+
+// run: if segment is "already used" (active, or passive that has subsequently
+//        been dropped), then only a zero length array can be created #1
+{
+    let { newElem } = wasmEvalText(`(module
+        (table 4 funcref)
+        (type $a (array funcref))
+        (elem $e (offset (i32.const 0)) funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem $a $e
+        )
+        )`).exports;
+    assertErrorMessage(() => {
+        newElem();
+    }, WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: if segment is "already used" (active, or passive that has subsequently
+//        been dropped), then only a zero length array can be created #2
+{
+    let { newElem } = wasmEvalText(`(module
+        (table 4 funcref)
+        (type $a (array funcref))
+        (elem $e (offset (i32.const 0)) funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=4 into elem ;) i32.const 4
+                (; size=0 into elem ;) i32.const 0
+                array.new_elem $a $e
+        )
+        )`).exports;
+    assertErrorMessage(() => {
+        newElem();
+    }, WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: if segment is "already used" (active, or passive that has subsequently
+//        been dropped), then only a zero length array can be created #3
+{
+    let { newElem } = wasmEvalText(`(module
+        (table 4 funcref)
+        (type $a (array funcref))
+        (elem $e (offset (i32.const 0)) funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=0 into elem ;) i32.const 0
+                array.new_elem $a $e
+        )
+        )`).exports;
+    let arr = newElem();
+    assertEq(arr.length, 0);
+}
+
+// run: range to copy would require OOB read on elem segment
+{
+    let { newElem } = wasmEvalText(`(module
+        (type $a (array funcref))
+        (elem $e funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 1
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem $a $e
+        )
+        )`).exports;
+    assertErrorMessage(() => {
+        newElem();
+    },WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: resulting array is as expected
+{
+    let { newElem, f1, f2, f3, f4 } = wasmEvalText(`(module
+        (type $a (array funcref))
+        (elem $e funcref $f1 $f2 $f3 $f4)
+        (func $f1 (export "f1"))
+        (func $f2 (export "f2"))
+        (func $f3 (export "f3"))
+        (func $f4 (export "f4"))
+        (func (export "newElem") (result eqref)
+                (; offset=0 into elem ;) i32.const 0
+                (; size=4 into elem ;) i32.const 4
+                array.new_elem $a $e
+        )
+        )`).exports;
+    let arr = newElem();
+    assertEq(arr.length, 4);
+    assertEq(arr[0], f1);
+    assertEq(arr[1], f2);
+    assertEq(arr[2], f3);
+    assertEq(arr[3], f4);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// array.copy
+/*
+  validation:
+    dest array must be mutable
+    validation: src and dest arrays must have compatible element types
+  run:
+    check for OOB conditions on src/dest arrays for non-zero length copies
+    check for OOB conditions on src/dest arrays for zero length copies
+    check resulting arrays are as expected
+    check that null src or dest array causes a trap
+*/
+
+// validation: dest array must be mutable
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array i32))
+    (func (param eqref)
+      (array.copy $a $a (local.get 0) (i32.const 1)
+                        (local.get 0) (i32.const 2) (i32.const 3))
+    )
+)
+`), WebAssembly.CompileError, /array is not mutable/);
+
+// validation: src and dest arrays must have compatible element types #1
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a32 (array (mut i32)))
+    (type $a8  (array i8))
+    (func (param eqref)
+      (array.copy $a32 $a8 (local.get 0) (i32.const 1)
+                           (local.get 0) (i32.const 2) (i32.const 3))
+    )
+)
+`), WebAssembly.CompileError, /incompatible element types/);
+
+// validation: src and dest arrays must have compatible element types #2
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a64 (array (mut i64)))
+    (type $aER (array eqref))
+    (func (param eqref)
+      (array.copy $a64 $aER (local.get 0) (i32.const 1)
+                            (local.get 0) (i32.const 2) (i32.const 3))
+    )
+)
+`), WebAssembly.CompileError, /incompatible element types/);
+
+// validation: src and dest arrays must have compatible element types #3
+//
+// We can only copy from a child (sub) reftype to a parent (super) reftype [or
+// to the same reftype.]  Here, we have an array of eqref and an array of
+// arrays.  An array is a child type of eqref, so it's invalid to try and copy
+// eqrefs into the array of arrays.
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $ty (array i32))
+    (type $child  (array (mut (ref $ty))))
+    (type $parent (array (mut eqref)))
+    (func (param (ref null $child) (ref null $parent))
+      ;; implied copy from parent to child -> not allowed
+      (array.copy $child $parent (local.get 1) (i32.const 1)
+                                 (local.get 0) (i32.const 2) (i32.const 3))
+    )
+)
+`), WebAssembly.CompileError, /incompatible element types/);
+
+// run: check for OOB conditions on src/dest arrays for non-zero length copies
+// run: check for OOB conditions on src/dest arrays for zero length copies
+// run: check resulting arrays are as expected
+const ARRAY_COPY_TESTS = [
+    // Format is:
+    //   array element type
+    //   corresponding value type
+    //   source array
+    //   first expected result
+    //   second expected result
+    //
+    // Value-type cases
+    [ 'i32', 'i32',
+      [22, 33, 44, 55, 66, 77],
+      [22, 55, 66, 77, 66, 77],
+      [22, 33, 22, 33, 44, 77]
+    ],
+    [ 'i64', 'i64',
+      [0x2022002220002n, 0x3033003330003n, 0x4044004440004n,
+       0x5055005550005n, 0x6066006660006n, 0x7077007770007n],
+      [0x2022002220002n, 0x5055005550005n, 0x6066006660006n,
+       0x7077007770007n, 0x6066006660006n, 0x7077007770007n],
+      [0x2022002220002n, 0x3033003330003n, 0x2022002220002n,
+       0x3033003330003n, 0x4044004440004n, 0x7077007770007n]
+    ],
+    [ 'f32', 'f32',
+      [22.0, 33.0, 44.0, 55.0, 66.0, 77.0],
+      [22.0, 55.0, 66.0, 77.0, 66.0, 77.0],
+      [22.0, 33.0, 22.0, 33.0, 44.0, 77.0]
+    ],
+    [ 'f64', 'f64',
+      [22.0, 33.0, 44.0, 55.0, 66.0, 77.0],
+      [22.0, 55.0, 66.0, 77.0, 66.0, 77.0],
+      [22.0, 33.0, 22.0, 33.0, 44.0, 77.0]
+    ],
+    [ 'externref', 'externref',
+      ['two', 'three', 'four',  'five',  'six', 'seven'],
+      ['two',  'five',  'six', 'seven',  'six', 'seven'],
+      ['two', 'three',  'two', 'three', 'four', 'seven']
+    ],
+    // non-Value-type cases
+    [ 'i8', 'i32',
+      [22, 33, 44, 55, 66, 77],
+      [22, 55, 66, 77, 66, 77],
+      [22, 33, 22, 33, 44, 77]
+    ],
+    [ 'i16', 'i32',
+      [22, 33, 44, 55, 66, 77],
+      [22, 55, 66, 77, 66, 77],
+      [22, 33, 22, 33, 44, 77]
+    ]
+];
+
+for (let [elemTy, valueTy, src, exp1, exp2] of ARRAY_COPY_TESTS) {
+    let { arrayNew, arrayCopy } = wasmEvalText(
+     `(module
+        (type $arrTy (array (mut ${elemTy})))
+        (func (export "arrayNew")
+              (param ${valueTy} ${valueTy} ${valueTy}
+                     ${valueTy} ${valueTy} ${valueTy})
+              (result eqref)
+          local.get 0
+          local.get 1
+          local.get 2
+          local.get 3
+          local.get 4
+          local.get 5
+          array.new_fixed $arrTy 6
+        )
+        (func (export "arrayCopy")
+              (param eqref i32 eqref i32 i32)
+          (array.copy $arrTy $arrTy
+            (ref.cast (ref null $arrTy) local.get 0) (local.get 1)
+            (ref.cast (ref null $arrTy) local.get 2) (local.get 3) (local.get 4)
+          )
+        )
+      )`
+    ).exports;
+
+    assertEq(src.length, 6);
+    assertEq(exp1.length, 6);
+    assertEq(exp2.length, 6);
+
+    function eqArrays(a1, a2) {
+        assertEq(a1.length, 6);
+        assertEq(a2.length, 6);
+        for (i = 0; i < 6; i++) {
+            if (a1[i] !== a2[i])
+                return false;
+        }
+        return true;
+    }
+    function show(who, arr) {
+        print(who + ": " + arr[0] + " " + arr[1] + " " + arr[2] + " "
+                         + arr[3] + " " + arr[4] + " " + arr[5] + " ");
+    }
+
+    // Check that "normal" copying gives expected results.
+    let srcTO;
+    srcTO = arrayNew(src[0], src[1], src[2], src[3], src[4], src[5]);
+    arrayCopy(srcTO, 1, srcTO, 3, 3);
+    assertEq(eqArrays(srcTO, exp1), true);
+
+    srcTO = arrayNew(src[0], src[1], src[2], src[3], src[4], src[5]);
+    arrayCopy(srcTO, 2, srcTO, 0, 3);
+    assertEq(eqArrays(srcTO, exp2), true);
+
+    // Check out-of-bounds conditions
+    let exp1TO = arrayNew(exp1[0], exp1[1], exp1[2], exp1[3], exp1[4], exp1[5]);
+    let exp2TO = arrayNew(exp2[0], exp2[1], exp2[2], exp2[3], exp2[4], exp2[5]);
+
+    // dst overrun, wants to write [5, 6]
+    assertErrorMessage(() => {
+        arrayCopy(exp1TO, 5, exp2TO, 1, 2);
+    },WebAssembly.RuntimeError, /index out of bounds/);
+
+    // dst overrun, wants to write [7, 8]
+    assertErrorMessage(() => {
+        arrayCopy(exp1TO, 7, exp2TO, 1, 2);
+    },WebAssembly.RuntimeError, /index out of bounds/);
+
+    // dst zero-len overrun, wants to write no elements, but starting at 9
+    assertErrorMessage(() => {
+        arrayCopy(exp1TO, 9, exp2TO, 1, 0);
+    },WebAssembly.RuntimeError, /index out of bounds/);
+
+    // src overrun, wants to read [5, 6]
+    assertErrorMessage(() => {
+        arrayCopy(exp1TO, 1, exp2TO, 5, 2);
+    },WebAssembly.RuntimeError, /index out of bounds/);
+
+    // src overrun, wants to read [7, 8]
+    assertErrorMessage(() => {
+        arrayCopy(exp1TO, 1, exp2TO, 7, 2);
+    },WebAssembly.RuntimeError, /index out of bounds/);
+
+    // src zero-len overrun, wants to read no elements, but starting at 9
+    assertErrorMessage(() => {
+        arrayCopy(exp1TO, 1, exp2TO, 9, 0);
+    },WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// run: check that null src or dest array causes a trap #1
+{
+  let { shouldTrap } = wasmEvalText(`(module
+    (type $a (array (mut f32)))
+    (func (export "shouldTrap")
+      ref.null $a
+      i32.const 1
+      (array.new_fixed $a 3 (f32.const 1.23) (f32.const 4.56) (f32.const 7.89))
+      i32.const 1
+      i32.const 1
+      array.copy $a $a
+    )
+  )`).exports;
+  assertErrorMessage(() => {
+    shouldTrap();
+  }, WebAssembly.RuntimeError, /null/);
+}
+
+// run: check that null src or dest array causes a trap #2
+{
+  let { shouldTrap } = wasmEvalText(`(module
+    (type $a (array (mut f32)))
+    (func (export "shouldTrap")
+      (array.new_fixed $a 3 (f32.const 1.23) (f32.const 4.56) (f32.const 7.89))
+      i32.const 1
+      ref.null $a
+      i32.const 1
+      i32.const 1
+      array.copy $a $a
+    )
+  )`).exports;
+  assertErrorMessage(() => {
+    shouldTrap();
+  }, WebAssembly.RuntimeError, /null/);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Checks for requests for oversize arrays (more than MaxArrayPayloadBytes),
+// where MaxArrayPayloadBytes == 1,987,654,321.
+
+// array.new
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array i32))
+    (func
+        ;; request exactly 2,000,000,000 bytes
+        (array.new $a (i32.const 0xABCD1234) (i32.const 500000000))
+        drop
+    )
+    (start 0)
+)
+`), WebAssembly.RuntimeError, /too many array elements/);
+
+// array.new_default
+assertErrorMessage(() => wasmEvalText(`(module
+    (type $a (array f64))
+    (func
+        ;; request exactly 2,000,000,000 bytes
+        (array.new_default $a (i32.const 250000000))
+        drop
+    )
+    (start 0)
+)
+`), WebAssembly.RuntimeError, /too many array elements/);
+
+// array.new_fixed
+// This is impossible to test because it would require to create, at a
+// minimum, 1,987,654,321 (MaxArrayPayloadBytes) / 16 = 124.3 million
+// values, if each value is a v128.  However, the max number of bytes per
+// function is 7,654,321 (MaxFunctionBytes).  Even if it were possible to
+// create a value using just one insn byte, there wouldn't be enough.
+
+// array.new_data
+// Similarly, impossible to test because the max data segment length is 1GB
+// (1,073,741,824 bytes) (MaxDataSegmentLengthPages * PageSize), which is less
+// than MaxArrayPayloadBytes.
+
+// array.new_element
+// Similarly, impossible to test because an element segment can contain at
+// most 10,000,000 (MaxElemSegmentLength) entries.
diff --git a/js/src/jit-test/tests/wasm/gc/binary.js b/js/src/jit-test/tests/wasm/gc/binary.js
new file mode 100644
index 0000000000..1ef4a586a8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/binary.js
@@ -0,0 +1,29 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+load(libdir + "wasm-binary.js");
+
+const v2vSig = {args:[], ret:VoidCode};
+const v2vSigSection = sigSection([v2vSig]);
+
+function checkInvalid(body, errorMessage) {
+    assertErrorMessage(() => new WebAssembly.Module(
+        moduleWithSections([v2vSigSection, declSection([0]), bodySection([body])])),
+                       WebAssembly.CompileError,
+                       errorMessage);
+}
+
+const invalidRefBlockType = funcBody({locals:[], body:[
+    BlockCode,
+    OptRefCode,
+    0x42,
+    EndCode,
+]});
+checkInvalid(invalidRefBlockType, /heap type/);
+
+const invalidTooBigRefType = funcBody({locals:[], body:[
+    BlockCode,
+    OptRefCode,
+    varU32(1000000),
+    EndCode,
+]});
+checkInvalid(invalidTooBigRefType, /heap type/);
diff --git a/js/src/jit-test/tests/wasm/gc/br-on-cast-fail.js b/js/src/jit-test/tests/wasm/gc/br-on-cast-fail.js
new file mode 100644
index 0000000000..3482f7815a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/br-on-cast-fail.js
@@ -0,0 +1,199 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+function typingModule(types, from, to, brParams, branchResults, fallthroughResults) {
+  return `(module
+    ${types}
+    (func
+      (param ${brParams.join(' ')})
+      (result ${branchResults.join(' ')})
+
+      (block (result ${fallthroughResults.join(' ')})
+        (; push params onto the stack in the same order as they appear, leaving
+          the last param at the top of the stack. ;)
+        ${brParams.map((_, i) => `local.get ${i}`).join('\n')}
+        br_on_cast_fail 1 ${from} ${to}
+      )
+      unreachable
+    )
+  )`;
+}
+
+function validTyping(types, from, to, brParams, branchResults, fallthroughResults) {
+  wasmValidateText(typingModule(types, from, to, brParams, branchResults, fallthroughResults));
+}
+
+function invalidTyping(types, from, to, brParams, branchResults, fallthroughResults, error) {
+  wasmFailValidateText(typingModule(types, from, to, brParams, branchResults, fallthroughResults), error);
+}
+
+// valid: eqref -> struct
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], ['eqref'], ['(ref $a)']);
+// valid: eqref -> struct (and looser types on results)
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], ['anyref'], ['(ref null $a)']);
+// valid: eqref -> nullable struct (note that branch type becomes non-nullable)
+validTyping('(type $a (struct))', 'eqref', '(ref null $a)', ['eqref'], ['(ref eq)'], ['(ref null $a)']);
+// valid: struct -> struct (from anyref)
+validTyping('(type $a (struct))', 'anyref', '(ref $a)', ['(ref $a)'], ['anyref'], ['(ref $a)']);
+// valid: struct -> struct (canonicalized)
+validTyping('(type $a (struct)) (type $b (struct))', '(ref $a)', '(ref $b)', ['(ref $a)'], ['(ref $b)'], ['(ref $a)']);
+// valid: nullable struct -> non-nullable struct (canonicalized)
+validTyping('(type $a (struct)) (type $b (struct))', '(ref null $a)', '(ref $b)', ['(ref null $a)'], ['(ref null $a)'], ['(ref $b)']);
+// valid: nullable struct -> nullable struct (canonicalized)
+validTyping('(type $a (struct)) (type $b (struct))', '(ref null $a)', '(ref null $b)', ['(ref null $a)'], ['(ref $a)'], ['(ref null $a)']);
+// valid: eqref -> struct with extra arg
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'eqref'], ['i32', 'eqref'], ['i32', '(ref $a)']);
+// valid: eqref -> struct with two extra args
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'f32', 'eqref'], ['i32', 'f32', 'eqref'], ['i32', 'f32', '(ref $a)']);
+
+// invalid: block result type must have slot for casted-to type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], [], ['(ref $a)'], /type mismatch/);
+// invalid: block result type must be supertype of casted-to type
+invalidTyping('(type $a (struct)) (type $b (struct (field i32)))', 'eqref', '(ref $a)', ['eqref'], ['(ref $b)'], ['(ref $a)'], /type mismatch/);
+// invalid: input is missing extra i32 from the branch target type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['f32', 'eqref'], ['i32', 'f32', 'eqref'], ['i32', 'f32', '(ref $a)'], /popping value/);
+// invalid: input has extra [i32, f32] swapped from the branch target type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'f32', 'eqref'], ['f32', 'i32', 'eqref'], ['i32', 'f32', '(ref $a)'], /type mismatch/);
+// invalid: input has extra [i32, f32] swapped from the branch fallthrough type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'f32', 'eqref'], ['i32', 'f32', 'eqref'], ['f32', 'i32', '(ref $a)'], /type mismatch/);
+// invalid: casting to non-nullable but fallthrough not nullable
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], ['(ref $a)'], ['(ref eq)'], /type mismatch/);
+// invalid: struct -> struct (same recursion group)
+invalidTyping('(rec (type $a (struct)) (type $b (struct)))', '(ref $a)', '(ref $b)', ['(ref $a)'], ['(ref $a)'], ['(ref $b)'], /type mismatch/);
+
+// Simple runtime test of cast-fail-ing
+{
+  let { makeA, makeB, isA, isB } = wasmEvalText(`(module
+    (type $a (struct))
+    (type $b (struct (field i32)))
+
+    (func (export "makeA") (result eqref)
+      struct.new_default $a
+    )
+
+    (func (export "makeB") (result eqref)
+      struct.new_default $b
+    )
+
+    (func (export "isA") (param eqref) (result i32)
+      (block (result eqref)
+        local.get 0
+        br_on_cast_fail 0 eqref (ref $a)
+
+        i32.const 1
+        br 1
+      )
+      drop
+      i32.const 0
+    )
+
+    (func (export "isB") (param eqref) (result i32)
+      (block (result eqref)
+        local.get 0
+        br_on_cast_fail 0 eqref (ref $b)
+
+        i32.const 1
+        br 1
+      )
+      drop
+      i32.const 0
+    )
+  )`).exports;
+
+  let a = makeA();
+  let b = makeB();
+
+  assertEq(isA(a), 1);
+  assertEq(isA(b), 0);
+  assertEq(isB(a), 0);
+  assertEq(isB(b), 1);
+}
+
+// Runtime test of cast-fail-ing with extra values
+{
+  function assertEqResults(a, b) {
+    if (!(a instanceof Array)) {
+      a = [a];
+    }
+    if (!(b instanceof Array)) {
+      b = [b];
+    }
+    if (a.length !== b.length) {
+      assertEq(a.length, b.length);
+    }
+    for (let i = 0; i < a.length; i++) {
+      let x = a[i];
+      let y = b[i];
+      // intentionally use loose equality to allow bigint to compare equally
+      // to number, as can happen with how we use the JS-API here.
+      assertEq(x == y, true);
+    }
+  }
+
+  function testExtra(values) {
+    let { makeT, makeF, select } = wasmEvalText(`(module
+      (type $t (struct))
+      (type $f (struct (field i32)))
+
+      (func (export "makeT") (result eqref)
+        struct.new_default $t
+      )
+      (func (export "makeF") (result eqref)
+        struct.new_default $f
+      )
+
+      (func (export "select")
+            (param eqref) (result ${values.map((type) => type).join(" ")})
+        (block (result eqref)
+          local.get 0
+          br_on_cast_fail 0 eqref (ref $t)
+
+          ${values.map((type, i) => `${type}.const ${values.length + i}`)
+                  .join("\n")}
+          br 1
+        )
+        drop
+        ${values.map((type, i) => `${type}.const ${i}`).join("\n")}
+      )
+    )`).exports;
+
+    let t = makeT();
+    let f = makeF();
+
+    let trueValues = values.map((type, i) => i);
+    let falseValues = values.map((type, i) => values.length + i);
+
+    assertEqResults(select(t), falseValues);
+    assertEqResults(select(f), trueValues);
+  }
+
+  // multiples of primitive valtypes
+  for (let valtype of ['i32', 'i64', 'f32', 'f64']) {
+    testExtra([valtype]);
+    testExtra([valtype, valtype]);
+    testExtra([valtype, valtype, valtype]);
+    testExtra([valtype, valtype, valtype, valtype, valtype, valtype, valtype, valtype]);
+  }
+
+  // random sundry of valtypes
+  testExtra(['i32', 'f32', 'i64', 'f64']);
+  testExtra(['i32', 'f32', 'i64', 'f64', 'i32', 'f32', 'i64', 'f64']);
+}
+
+// This test causes the `values` vector returned by
+// `OpIter<Policy>::readBrOnCastFail` to contain three entries, the last of
+// which is the argument, hence is reftyped.  This is used to verify an
+// assertion to that effect in FunctionCompiler::brOnCastCommon.
+{
+    let tOnCastFail =
+    `(module
+       (type $a (struct))
+       (func (export "onCastFail") (param f32 i32 eqref) (result f32 i32 eqref)
+         local.get 0
+         local.get 1
+         local.get 2
+         br_on_cast_fail 0 eqref (ref $a)
+         unreachable
+       )
+     )`;
+    let { onCastFail } = wasmEvalText(tOnCastFail).exports;
+}
diff --git a/js/src/jit-test/tests/wasm/gc/br-on-cast.js b/js/src/jit-test/tests/wasm/gc/br-on-cast.js
new file mode 100644
index 0000000000..cf83f1ba00
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/br-on-cast.js
@@ -0,0 +1,197 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+function typingModule(types, from, to, brParams, branchResults, fallthroughResults) {
+  return `(module
+    ${types}
+    (func
+      (param ${brParams.join(' ')})
+      (result ${branchResults.join(' ')})
+
+      (block (result ${fallthroughResults.join(' ')})
+        (; push params onto the stack in the same order as they appear, leaving
+          the last param at the top of the stack. ;)
+        ${brParams.map((_, i) => `local.get ${i}`).join('\n')}
+        br_on_cast 1 ${from} ${to}
+      )
+      unreachable
+    )
+  )`;
+}
+
+function validTyping(types, from, to, brParams, branchResults, fallthroughResults) {
+  wasmValidateText(typingModule(types, from, to, brParams, branchResults, fallthroughResults));
+}
+
+function invalidTyping(types, from, to, brParams, branchResults, fallthroughResults, error) {
+  wasmFailValidateText(typingModule(types, from, to, brParams, branchResults, fallthroughResults), error);
+}
+
+// valid: eqref -> struct
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], ['(ref $a)'], ['eqref']);
+// valid: eqref -> struct (and looser types on results)
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], ['(ref null $a)'], ['anyref']);
+// valid: eqref -> nullable struct (note that fallthrough becomes non-nullable)
+validTyping('(type $a (struct))', 'eqref', '(ref null $a)', ['eqref'], ['(ref null $a)'], ['(ref eq)']);
+// valid: struct -> struct (from anyref)
+validTyping('(type $a (struct))', 'anyref', '(ref $a)', ['(ref $a)'], ['(ref $a)'], ['anyref']);
+// valid: struct -> struct (canonicalized)
+validTyping('(type $a (struct)) (type $b (struct))', '(ref $a)', '(ref $b)', ['(ref $a)'], ['(ref $b)'], ['(ref $b)']);
+// valid: nullable struct -> non-nullable struct (canonicalized)
+validTyping('(type $a (struct)) (type $b (struct))', '(ref null $a)', '(ref $b)', ['(ref null $a)'], ['(ref $b)'], ['(ref null $a)']);
+// valid: nullable struct -> nullable struct (canonicalized)
+validTyping('(type $a (struct)) (type $b (struct))', '(ref null $a)', '(ref null $b)', ['(ref null $a)'], ['(ref null $a)'], ['(ref $a)']);
+// valid: eqref -> struct with extra arg
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'eqref'], ['i32', '(ref $a)'], ['i32', 'eqref']);
+// valid: eqref -> struct with two extra args
+validTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'f32', 'eqref'], ['i32', 'f32', '(ref $a)'], ['i32', 'f32', 'eqref']);
+
+// invalid: block result type must have slot for casted-to type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], [], ['eqref'], /type mismatch/);
+// invalid: block result type must be supertype of casted-to type
+invalidTyping('(type $a (struct)) (type $b (struct (field i32)))', 'eqref', '(ref $a)', ['eqref'], ['(ref $b)'], ['(ref $a)'], /type mismatch/);
+// invalid: input is missing extra i32 from the branch target type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['f32', 'eqref'], ['i32', 'f32', '(ref $a)'], ['i32', 'f32', 'eqref'], /popping value/);
+// invalid: input has extra [i32, f32] swapped from the branch target type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'f32', 'eqref'], ['f32', 'i32', '(ref $a)'], ['i32', 'f32', 'eqref'], /type mismatch/);
+// invalid: input has extra [i32, f32] swapped from the branch fallthrough type
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['i32', 'f32', 'eqref'], ['i32', 'f32', '(ref $a)'], ['f32', 'i32', 'eqref'], /type mismatch/);
+// invalid: casting to non-nullable but fallthrough not nullable
+invalidTyping('(type $a (struct))', 'eqref', '(ref $a)', ['eqref'], ['(ref $a)'], ['(ref eq)'], /type mismatch/);
+// invalid: struct -> struct (same recursion group)
+invalidTyping('(rec (type $a (struct)) (type $b (struct)))', '(ref $a)', '(ref $b)', ['(ref $a)'], ['(ref $b)'], ['(ref $a)'], /type mismatch/);
+
+// Simple runtime test of casting
+{
+  let { makeA, makeB, isA, isB } = wasmEvalText(`(module
+    (type $a (struct))
+    (type $b (sub $a (struct (field i32))))
+
+    (func (export "makeA") (result eqref)
+      struct.new_default $a
+    )
+
+    (func (export "makeB") (result eqref)
+      struct.new_default $b
+    )
+
+    (func (export "isA") (param eqref) (result i32)
+      (block (result (ref $a))
+        local.get 0
+        br_on_cast 0 anyref (ref $a)
+
+        i32.const 0
+        br 1
+      )
+      drop
+      i32.const 1
+    )
+
+    (func (export "isB") (param eqref) (result i32)
+      (block (result (ref $a))
+        local.get 0
+        br_on_cast 0 anyref (ref $b)
+
+        i32.const 0
+        br 1
+      )
+      drop
+      i32.const 1
+    )
+  )`).exports;
+
+  let a = makeA();
+  let b = makeB();
+
+  assertEq(isA(a), 1);
+  assertEq(isA(b), 1);
+  assertEq(isB(a), 0);
+  assertEq(isB(b), 1);
+}
+
+// Runtime test of casting with extra values
+{
+  function assertEqResults(a, b) {
+    if (!(a instanceof Array)) {
+      a = [a];
+    }
+    if (!(b instanceof Array)) {
+      b = [b];
+    }
+    if (a.length !== b.length) {
+      assertEq(a.length, b.length);
+    }
+    for (let i = 0; i < a.length; i++) {
+      let x = a[i];
+      let y = b[i];
+      // intentionally use loose equality to allow bigint to compare equally
+      // to number, as can happen with how we use the JS-API here.
+      assertEq(x == y, true);
+    }
+  }
+
+  function testExtra(values) {
+    let { makeT, makeF, select } = wasmEvalText(`(module
+      (type $t (struct))
+      (type $f (struct (field i32)))
+
+      (func (export "makeT") (result eqref)
+        struct.new_default $t
+      )
+      (func (export "makeF") (result eqref)
+        struct.new_default $f
+      )
+
+      (func (export "select") (param eqref) (result ${values.map((type) => type).join(" ")})
+        (block (result (ref $t))
+          local.get 0
+          br_on_cast 0 anyref (ref $t)
+
+          ${values.map((type, i) => `${type}.const ${values.length + i}`).join("\n")}
+          br 1
+        )
+        drop
+        ${values.map((type, i) => `${type}.const ${i}`).join("\n")}
+      )
+    )`).exports;
+
+    let t = makeT();
+    let f = makeF();
+
+    let trueValues = values.map((type, i) => i);
+    let falseValues = values.map((type, i) => values.length + i);
+
+    assertEqResults(select(t), trueValues);
+    assertEqResults(select(f), falseValues);
+  }
+
+  // multiples of primitive valtypes
+  for (let valtype of ['i32', 'i64', 'f32', 'f64']) {
+    testExtra([valtype]);
+    testExtra([valtype, valtype]);
+    testExtra([valtype, valtype, valtype]);
+    testExtra([valtype, valtype, valtype, valtype, valtype, valtype, valtype, valtype]);
+  }
+
+  // random sundry of valtypes
+  testExtra(['i32', 'f32', 'i64', 'f64']);
+  testExtra(['i32', 'f32', 'i64', 'f64', 'i32', 'f32', 'i64', 'f64']);
+}
+
+// This test causes the `values` vector returned by
+// `OpIter<Policy>::readBrOnCast` to contain three entries, the last of which
+// is the argument, hence is reftyped.  This is used to verify an assertion to
+// that effect in FunctionCompiler::brOnCastCommon.
+{
+    let tOnCast =
+    `(module
+       (type $a (struct))
+       (func (export "onCast") (param f32 i32 eqref) (result f32 i32 (ref $a))
+         local.get 0
+         local.get 1
+         local.get 2
+         br_on_cast 0 anyref (ref $a)
+         unreachable
+       )
+     )`;
+    let { onCast } = wasmEvalText(tOnCast).exports;
+}
diff --git a/js/src/jit-test/tests/wasm/gc/cast-abstract.js b/js/src/jit-test/tests/wasm/gc/cast-abstract.js
new file mode 100644
index 0000000000..ec2a44014c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/cast-abstract.js
@@ -0,0 +1,264 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+const preamble = `
+  (type $s1 (struct))
+  (type $s2 (sub $s1 (struct (field i32))))
+  (type $a1 (array (ref null $s1)))
+  (type $a2 (sub $a1 (array (ref null $s2))))
+  (type $f1 (func))
+
+  (func $f (type $f1))
+  (elem declare func $f) ;; allow $f to be ref.func'd
+`;
+
+// All the concrete subtype relationships present in the preamble.
+// [x, y] means x <: y.
+const subtypes = [
+  ['$s2', '$s1'],
+  ['$a2', '$a1'],
+];
+
+const typeSets = [
+  [
+    { name: 'any' },
+    { name: 'eq' },
+    { name: 'struct' },
+    { name: '$s1', make: 'struct.new_default $s1' },
+    { name: '$s2', make: 'struct.new_default $s2' },
+    { name: 'none', none: true },
+  ],
+  [
+    { name: 'any' },
+    { name: 'eq' },
+    { name: 'array' },
+    { name: '$a1', make: '(array.new_default $a1 (i32.const 10))' },
+    { name: '$a2', make: '(array.new_default $a2 (i32.const 10))' },
+    { name: 'none', none: true },
+  ],
+  [
+    { name: 'any' },
+    { name: 'eq' },
+    { name: '$s1', make: 'struct.new_default $s1' },
+    { name: '$s2', make: 'struct.new_default $s2' },
+    { name: '$a1', make: '(array.new_default $a1 (i32.const 10))' },
+    { name: '$a2', make: '(array.new_default $a2 (i32.const 10))' },
+    { name: 'none', none: true },
+  ],
+  // i31 eventually
+
+  // Apparently we don't support casting functions yet? That should be remedied...
+  // [
+  //   { name: 'func' },
+  //   { name: '$f1', make: 'ref.func $f' },
+  //   { name: 'nofunc', none: true },
+  // ],
+
+  // TODO: extern
+];
+
+const nullables = [       // for example:
+  [true, true, true],     // null $s1 -> null any -> null eq
+  [true, true, false],    // null $s1 -> null any -> eq
+  [true, false, true],    // null $s1 -> any -> null eq
+  [true, false, false],   // null $s1 -> any -> eq
+  [false, true, true],    // $s1 -> null any -> null eq
+  [false, true, false],   // $s1 -> null any -> eq
+  [false, false, true],   // $s1 -> any -> null eq
+  [false, false, false],  // $s1 -> any -> eq
+]
+
+function isSubtype(src, dest) {
+  if (src.name === dest.name) {
+    return true;
+  }
+  for (const [src2, dest2] of subtypes) {
+    if (src.name === src2 && dest.name === dest2) {
+      return true;
+    }
+  }
+  return false;
+}
+
+let numCases = 0;
+
+// Replace this with a string like 'non-null (ref $s1) -> (ref any) -> (ref any)' to test exactly one specific case. Makes debugging easier.
+const specificTest = '';
+
+// This will generate an enormous pile of test cases. All of these should be valid,
+// as in passing WebAssembly.validate, but some may not be good casts at runtime.
+for (const typeSet of typeSets) {
+  for (const start of typeSet) {
+    for (const middle of typeSet) {
+      for (const end of typeSet) {
+        for (const [nullable0, nullable1, nullable2] of nullables) {
+          for (const makeNull of [true, false]) {
+            const concrete0 = !!start.make;
+            const concrete1 = !!middle.make;
+            const concrete2 = !!end.make;
+
+            if (!concrete0 && !makeNull) {
+              // We can only start with null values for abstract types
+              continue;
+            }
+
+            if (!nullable0 && makeNull) {
+              // Can't use null as a valid value for a non-nullable type
+              continue;
+            }
+
+            numCases += 1;
+
+            let good1 = true;
+            let good2 = true;
+
+            // Null values will fail casts to non-nullable types
+            if (makeNull) {
+              if (!nullable1) {
+                good1 = false;
+              }
+              if (!nullable2) {
+                good2 = false;
+              }
+            }
+
+            // Bottom types can't represent non-null, so this will always fail
+            if (!makeNull) {
+              if (middle.none) {
+                good1 = false;
+              }
+              if (end.none) {
+                good2 = false;
+              }
+            }
+
+            // Concrete values are subject to subtyping relationships
+            if (!makeNull) {
+              if (concrete1 && !isSubtype(start, middle)) {
+                good1 = false;
+              }
+              if (concrete2 && !isSubtype(start, end)) {
+                good2 = false;
+              }
+            }
+
+            let emoji1 = good1 ? '✅' : '❌';
+            let emoji2 = good2 ? '✅' : '❌';
+
+            if (!good1) {
+              good2 = false;
+              emoji2 = '❓';
+            }
+
+            const name = `${makeNull ? 'null' : 'non-null'} (ref ${nullable0 ? 'null ' : ''}${start.name}) -> (ref ${nullable1 ? 'null ' : ''}${middle.name}) -> (ref ${nullable2 ? 'null ' : ''}${end.name})`;
+            if (specificTest && name != specificTest) {
+              continue;
+            }
+
+            print(`${emoji1}${emoji2} ${name}`);
+            const make = makeNull ? `ref.null ${start.name}` : start.make;
+            const type1 = `(ref ${nullable1 ? 'null ' : ''}${middle.name})`;
+            const type2 = `(ref ${nullable2 ? 'null ' : ''}${end.name})`;
+            const moduleText = `(module
+              ${preamble}
+              (func (export "cast1") (result ${type1})
+                ${make}
+                ref.cast ${type1}
+              )
+              (func (export "cast2") (param ${type1}) (result ${type2})
+                local.get 0
+                ref.cast ${type2}
+              )
+
+              (func (export "test1") (result i32)
+                ${make}
+                ref.test ${type1}
+              )
+              (func (export "test2") (param ${type1}) (result i32)
+                local.get 0
+                ref.test ${type2}
+              )
+
+              ;; these are basically ref.test but with branches
+              (func (export "branch1") (result i32)
+                (block (result ${type1})
+                  ${make}
+                  br_on_cast 0 anyref ${type1}
+                  drop
+                  (return (i32.const 0))
+                )
+                drop
+                (return (i32.const 1))
+              )
+              (func (export "branch2") (param ${type1}) (result i32)
+                (block (result ${type2})
+                  local.get 0
+                  br_on_cast 0 anyref ${type2}
+                  drop
+                  (return (i32.const 0))
+                )
+                drop
+                (return (i32.const 1))
+              )
+              (func (export "branchfail1") (result i32)
+                (block (result anyref)
+                  ${make}
+                  br_on_cast_fail 0 anyref ${type1}
+                  drop
+                  (return (i32.const 1))
+                )
+                drop
+                (return (i32.const 0))
+              )
+              (func (export "branchfail2") (param ${type1}) (result i32)
+                (block (result anyref)
+                  local.get 0
+                  br_on_cast_fail 0 anyref ${type2}
+                  drop
+                  (return (i32.const 1))
+                )
+                drop
+                (return (i32.const 0))
+              )
+            )`;
+
+            try {
+              // The casts are split up so the stack trace will show you which cast is failing.
+              const {
+                cast1, cast2,
+                test1, test2,
+                branch1, branch2,
+                branchfail1, branchfail2,
+              } = wasmEvalText(moduleText).exports;
+
+              function assertCast(func, good) {
+                if (good) {
+                  return [func(), true];
+                } else {
+                  assertErrorMessage(func, WebAssembly.RuntimeError, /bad cast/);
+                  return [null, false];
+                }
+              }
+
+              const [res1, ok1] = assertCast(cast1, good1);
+              assertEq(test1(), good1 ? 1 : 0);
+              assertEq(branch1(), good1 ? 1 : 0);
+              assertEq(branchfail1(), good1 ? 1 : 0);
+              if (ok1) {
+                assertCast(() => cast2(res1), good2);
+                assertEq(test2(res1), good2 ? 1 : 0);
+                assertEq(branch2(res1), good2 ? 1 : 0);
+                assertEq(branchfail2(res1), good2 ? 1 : 0);
+              }
+            } catch (e) {
+              print("Failed! Module text was:");
+              print(moduleText);
+              throw e;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+print(`we hope you have enjoyed these ${numCases} test cases 😁`);
diff --git a/js/src/jit-test/tests/wasm/gc/cast-extern.js b/js/src/jit-test/tests/wasm/gc/cast-extern.js
new file mode 100644
index 0000000000..9fd9ddf2c9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/cast-extern.js
@@ -0,0 +1,54 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Casting an external value is an expected failure
+let { refCast, refTest, brOnCast, brOnCastFail } = wasmEvalText(`
+  (module
+    (; give this struct a unique identity to avoid conflict with
+       the struct type defined in wasm.js ;)
+    (type (struct i64 i32 i64 i32))
+
+    (func (export "refTest") (param externref) (result i32)
+      local.get 0
+      extern.internalize
+      ref.test (ref 0)
+    )
+    (func (export "refCast") (param externref) (result i32)
+      local.get 0
+      extern.internalize
+      ref.cast (ref null 0)
+      drop
+      i32.const 0
+    )
+    (func (export "brOnCast") (param externref) (result i32)
+      (block (result (ref 0))
+        local.get 0
+        extern.internalize
+        br_on_cast 0 anyref (ref 0)
+        drop
+        i32.const 0
+        br 1
+      )
+      drop
+      i32.const 1
+    )
+    (func (export "brOnCastFail") (param externref) (result i32)
+      (block (result anyref)
+        local.get 0
+        extern.internalize
+        br_on_cast_fail 0 anyref (ref 0)
+        drop
+        i32.const 1
+        br 1
+      )
+      drop
+      i32.const 0
+    )
+  )
+`).exports;
+
+for (let v of WasmNonNullExternrefValues) {
+  assertErrorMessage(() => refCast(v), WebAssembly.RuntimeError, /bad cast/);
+  assertEq(refTest(v), 0);
+  assertEq(brOnCast(v), 0);
+  assertEq(brOnCastFail(v), 0);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/casting.js b/js/src/jit-test/tests/wasm/gc/casting.js
new file mode 100644
index 0000000000..7c07bfcf69
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/casting.js
@@ -0,0 +1,128 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Test the maximum depth limit
+{
+  const MaxDepth = 31;
+  let types = `(type (struct))\n`;
+  for (let depth = 1; depth <= MaxDepth + 1; depth++) {
+    types += `(type (sub ${depth - 1} (struct)))\n`;
+  }
+  wasmFailValidateText(`(module
+    ${types}
+  )`, /too deep/);
+}
+
+// Test all possible casting combinations of the following graph:
+//
+//  A1       A2
+//  |        |
+//  B1       B2
+//  | \      |
+//  C1  C2   C3
+//  | \      |
+//  D1  D2   D3
+//  | \      |
+//  E1  E2   E3
+//  | \      |
+//  F1  F2   F3
+//  | \      |
+//  G1  G2   G3
+//  | \      |
+//  H1  H2   H3
+//  | \      |
+//  I1  I2   I3
+//  | \      |
+//  J1  J2   J3
+//
+// NOTE: this object will be mutated and needs to be ordered such that parent
+// definitions come before children.  Note also, to be properly effective,
+// these trees need to have a depth of at least MinSuperTypeVectorLength as
+// defined in wasm/WasmCodegenConstants.h; keep it in sync with that.
+const TYPES = {
+  'A1': { super: null },
+  'A2': { super: null },
+  'B1': { super: 'A1' },
+  'B2': { super: 'A2' },
+  'C1': { super: 'B1' },
+  'C2': { super: 'B1' },
+  'C3': { super: 'B2' },
+  'D1': { super: 'C1' },
+  'D2': { super: 'C1' },
+  'D3': { super: 'C3' },
+  'E1': { super: 'D1' },
+  'E2': { super: 'D1' },
+  'E3': { super: 'D3' },
+  'F1': { super: 'E1' },
+  'F2': { super: 'E1' },
+  'F3': { super: 'E3' },
+  'G1': { super: 'F1' },
+  'G2': { super: 'F1' },
+  'G3': { super: 'F3' },
+  'H1': { super: 'G1' },
+  'H2': { super: 'G1' },
+  'H3': { super: 'G3' },
+  'I1': { super: 'H1' },
+  'I2': { super: 'H1' },
+  'I3': { super: 'H3' },
+  'J1': { super: 'I1' },
+  'J2': { super: 'I1' },
+  'J3': { super: 'I3' },
+};
+
+// The oracle method for testing the declared subtype relationship.
+function manualIsSubtype(types, subType, superType) {
+  while (subType !== superType && subType.super !== null) {
+    subType = types[subType.super];
+  }
+  return subType === superType;
+}
+
+function testAllCasts(types) {
+  let typeSection = ``;
+  let funcSection = ``;
+  for (let name in types) {
+    let type = types[name];
+    if (type.super === null) {
+      typeSection += `(type \$${name} (struct))\n`;
+    } else {
+      typeSection += `(type \$${name} (sub \$${type.super} (struct)))\n`;
+    }
+    funcSection += `
+      (func (export "new${name}") (result externref)
+        struct.new_default \$${name}
+        extern.externalize
+      )
+      (func (export "is${name}") (param externref) (result i32)
+        local.get 0
+        extern.internalize
+        ref.test (ref \$${name})
+      )`;
+  }
+  // NOTE: we place all types in a single recursion group to prevent
+  // canonicalization from 
+  let moduleText = `(module
+    (rec ${typeSection})
+    ${funcSection}
+  )`;
+
+  // Instantiate the module and acquire the testing methods
+  let exports = wasmEvalText(moduleText).exports;
+  for (let name in types) {
+    let type = types[name];
+    type['new'] = exports[`new${name}`];
+    type['is'] = exports[`is${name}`];
+  }
+
+  // Test every combination of types, comparing the oracle method against the
+  // JIT'ed method.
+  for (let subTypeName in types) {
+    let subType = types[subTypeName];
+    for (let superTypeName in types) {
+      let superType = types[subTypeName];
+      assertEq(
+        manualIsSubtype(types, subType, superType) ? 1 : 0,
+        superType['is'](subType['new']()));
+    }
+  }
+}
+testAllCasts(TYPES);
diff --git a/js/src/jit-test/tests/wasm/gc/debugger.js b/js/src/jit-test/tests/wasm/gc/debugger.js
new file mode 100644
index 0000000000..dea6581eb8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/debugger.js
@@ -0,0 +1,38 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+
+(function() {
+    let g = newGlobal({newCompartment: true});
+    let dbg = new Debugger(g);
+    g.eval(`o = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module (func (param externref) (result externref) local.get 0) (export "" (func 0)))')));`);
+})();
+
+(function() {
+    var g = newGlobal({newCompartment: true});
+    g.parent = this;
+
+    let src = `
+      (module
+        (func (export "func") (param $ref externref) (result externref)
+            local.get $ref
+        )
+      )
+    `;
+
+    g.eval(`
+        var obj = { somekey: 'somevalue' };
+        Debugger(parent).onEnterFrame = function(frame) {
+            let v = frame.environment.getVariable('var0');
+            assertEq(typeof v, 'object');
+
+            let prop = v.unwrap().getOwnPropertyDescriptor('somekey');
+            assertEq(typeof prop, 'object');
+            assertEq(typeof prop.value, 'string');
+            assertEq(prop.value, 'somevalue');
+
+            // Disable onEnterFrame hook.
+            Debugger(parent).onEnterFrame = undefined;
+        };
+    `);
+
+    new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`${src}`))).exports.func(g.obj);
+})();
diff --git a/js/src/jit-test/tests/wasm/gc/directives.txt b/js/src/jit-test/tests/wasm/gc/directives.txt
new file mode 100644
index 0000000000..49594ced70
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-function-references --wasm-gc; test-also=--wasm-compiler=baseline --wasm-function-references --wasm-gc; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/gc/disabled.js b/js/src/jit-test/tests/wasm/gc/disabled.js
new file mode 100644
index 0000000000..791c6ff25e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/disabled.js
@@ -0,0 +1,25 @@
+// |jit-test| skip-if: wasmGcEnabled()
+
+const { CompileError, validate } = WebAssembly;
+
+const UNRECOGNIZED_OPCODE_OR_BAD_TYPE = /unrecognized opcode|(Structure|reference|gc) types not enabled|invalid heap type|invalid inline block type|bad type|\(ref T\) types not enabled|Invalid type|invalid function type/;
+
+let simpleTests = [
+    "(module (func (drop (ref.null eq))))",
+    "(module (func $test (local eqref)))",
+    "(module (func $test (param eqref)))",
+    "(module (func $test (result eqref) (ref.null eq)))",
+    "(module (func $test (block (result eqref) (unreachable)) unreachable))",
+    "(module (func $test (result i32) (local eqref) (ref.is_null (local.get 0))))",
+    `(module (import "a" "b" (func (param eqref))))`,
+    `(module (import "a" "b" (func (result eqref))))`,
+    `(module (type $s (struct)))`,
+];
+
+// Test that use of gc-types fails when gc is disabled.
+
+for (let src of simpleTests) {
+    let bin = wasmTextToBinary(src);
+    assertEq(validate(bin), false);
+    wasmCompilationShouldFail(bin, UNRECOGNIZED_OPCODE_OR_BAD_TYPE);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/externref-boxing-struct.js b/js/src/jit-test/tests/wasm/gc/externref-boxing-struct.js
new file mode 100644
index 0000000000..b9cfed080f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/externref-boxing-struct.js
@@ -0,0 +1,74 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Moving a JS value through a wasm externref is a pair of boxing/unboxing
+// conversions that leaves the value unchanged.  There are many cases,
+// along these axes:
+//
+//  - global variables, see externref-boxing.js
+//  - tables, see externref-boxing.js
+//  - function parameters and returns, see externref-boxing.js
+//  - struct fields [for the gc feature], this file
+//  - TypedObject fields when we construct with the externref type; this file
+
+// Struct fields of externref type can receive their value in these ways:
+//
+// - the struct.new and struct.set instructions
+// - storing into mutable fields from JS
+// - from a constructor called from JS
+//
+// Struct fields can be read in these ways:
+//
+// - the struct.get instruction
+// - reading the field from JS
+//
+// We're especially interested in two cases: where JS stores a non-object value
+// into a field, in this case there should be boxing; and where JS reads a
+// non-pointer value from a field, in this case there should be unboxing.
+
+// Write with struct.new, read with the JS getter
+
+for (let v of WasmExternrefValues)
+{
+    let ins = wasmEvalText(
+        `(module
+           (type $S (struct (field $S.x (mut externref))))
+           (func (export "make") (param $v externref) (result eqref)
+             (struct.new $S (local.get $v))))`);
+    let x = ins.exports.make(v);
+    assertEq(x[0], v);
+}
+
+// Try to make sure externrefs are properly traced
+
+{
+    let fields = iota(10).map(() => `(field externref)`).join(' ');
+    let params = iota(10).map((i) => `(param $${i} externref)`).join(' ');
+    let args = iota(10).map((i) => `(local.get $${i})`).join(' ');
+    let txt = `(module
+                 (type $S (struct ${fields}))
+                 (func (export "make") ${params} (result eqref)
+                   (struct.new $S ${args})))`;
+    let ins = wasmEvalText(txt);
+    let x = ins.exports.make({x:0}, {x:1}, {x:2}, {x:3}, {x:4}, {x:5}, {x:6}, {x:7}, {x:8}, {x:9})
+    gc('shrinking');
+    assertEq(typeof x[0], "object");
+    assertEq(x[0].x, 0);
+    assertEq(typeof x[1], "object");
+    assertEq(x[1].x, 1);
+    assertEq(typeof x[2], "object");
+    assertEq(x[2].x, 2);
+    assertEq(typeof x[3], "object");
+    assertEq(x[3].x, 3);
+    assertEq(typeof x[4], "object");
+    assertEq(x[4].x, 4);
+    assertEq(typeof x[5], "object");
+    assertEq(x[5].x, 5);
+    assertEq(typeof x[6], "object");
+    assertEq(x[6].x, 6);
+    assertEq(typeof x[7], "object");
+    assertEq(x[7].x, 7);
+    assertEq(typeof x[8], "object");
+    assertEq(x[8].x, 8);
+    assertEq(typeof x[9], "object");
+    assertEq(x[9].x, 9);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/externref-conversions.js b/js/src/jit-test/tests/wasm/gc/externref-conversions.js
new file mode 100644
index 0000000000..12c5a2bbcc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/externref-conversions.js
@@ -0,0 +1,94 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Output type is non-nullable if the input type is non-nullable
+wasmValidateText(`(module
+	(func (param externref) (result anyref)
+		local.get 0
+		extern.internalize
+	)
+	(func (param anyref) (result externref)
+		local.get 0
+		extern.externalize
+	)
+	(func (param (ref extern)) (result (ref any))
+		local.get 0
+		extern.internalize
+	)
+	(func (param (ref any)) (result (ref extern))
+		local.get 0
+		extern.externalize
+	)
+	(func (result (ref any))
+	    unreachable
+	    extern.internalize
+	)
+	(func (result (ref extern))
+	    unreachable
+	    extern.externalize
+	)
+)`);
+
+// Output type is nullable if the input type is nullable
+wasmFailValidateText(`(module
+	(func (param externref) (result (ref any))
+		local.get 0
+		extern.internalize
+	)
+)`, /expected/);
+wasmFailValidateText(`(module
+	(func (param anyref) (result (ref extern))
+		local.get 0
+		extern.externalize
+	)
+)`, /expected/);
+
+// Can round trip an externref through anyref and get the same thing back
+let {roundtripThroughAny} = wasmEvalText(`(module
+	(func (export "roundtripThroughAny") (param externref) (result externref)
+	  local.get 0
+	  extern.internalize
+	  extern.externalize
+	)
+)`).exports;
+for (let value of WasmExternrefValues) {
+	assertEq(value, roundtripThroughAny(value));
+}
+
+// Can round trip GC objects through externref and get the same thing back
+let {testStruct, testArray} = wasmEvalText(`(module
+	(type $struct (struct))
+	(type $array (array i32))
+
+	(func (export "testStruct") (result i32)
+	  (local (ref $struct))
+	  (local.set 0 struct.new $struct)
+      local.get 0
+	  (ref.eq
+	  	(ref.cast (ref null $struct)
+	  	  (extern.internalize
+	  	    (extern.externalize
+	  	      local.get 0
+	  	    )
+	  	  )
+	  	)
+	  )
+	)
+
+	(func (export "testArray") (result i32)
+	  (local (ref $array))
+	  (local.set 0 (array.new $array i32.const 0 i32.const 0))
+      local.get 0
+	  (ref.eq
+	  	(ref.cast (ref null $array)
+	  	  (extern.internalize
+	  	    (extern.externalize
+	  	      local.get 0
+	  	    )
+	  	  )
+	  	)
+	  )
+	)
+)`).exports;
+
+assertEq(testStruct(), 1);
+assertEq(testArray(), 1);
diff --git a/js/src/jit-test/tests/wasm/gc/function_subtyping.js b/js/src/jit-test/tests/wasm/gc/function_subtyping.js
new file mode 100644
index 0000000000..6b4e719a74
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/function_subtyping.js
@@ -0,0 +1,79 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Validate rules for function subtyping:
+// - Same number of parameters and results
+// - Function return types are covariant
+// - Function parameter types are contravariant
+wasmValidateText(
+`(module
+    (type $A (struct (field i32)))
+    (type $B (sub $A (struct (field i32) (field i32))))
+    (type $C (sub $B (struct (field i32) (field i32) (field i64))))
+    (type $D (sub $B (struct (field i32) (field i32) (field f32))))
+
+    ;; Same types (invariant)
+    (type $func1 (func (param (ref $A) (ref $A)) (result (ref $C))))
+    (type $func2 (sub $func1 (func (param (ref $A) (ref $A)) (result (ref $C)))))
+
+    ;; Covariant return types are valid
+    (type $func3 (func (param (ref $A) (ref $A)) (result (ref $B))))
+    (type $func4 (sub $func3 (func (param (ref $A) (ref $A)) (result (ref $C)))))
+    (type $func5 (func (param (ref $A) (ref $A)) (result (ref $A) (ref $B))))
+    (type $func6 (sub $func5 (func (param (ref $A) (ref $A)) (result (ref $D) (ref $C)))))
+
+    ;; Contravariant parameter types are valid
+    (type $func7 (func (param (ref $A) (ref $C)) (result (ref $C))))
+    (type $func8 (sub $func7 (func (param (ref $A) (ref $B)) (result (ref $C)))))
+    (type $func9 (func (param (ref $D) (ref $C)) (result (ref $C))))
+    (type $func10 (sub $func9 (func (param (ref $A) (ref $B)) (result (ref $C)))))
+
+    ;; Mixing covariance and contravariance
+    (type $func11 (func (param (ref $D) (ref $C)) (result (ref $A))))
+    (type $func12 (sub $func11 (func (param (ref $A) (ref $B)) (result (ref $C)))))
+)
+`);
+
+// Validate that incorrect subtyping examples are failing as expected
+const typeError = /incompatible super type/;
+
+var code =`
+(module
+    (type $A (struct (field i32)))
+    (type $B (sub $A (struct (field i32) (field i32))))
+    (type $C (sub $B (struct (field i32) (field i32) (field i64))))
+    (type $D (sub $B (struct (field i32) (field i32) (field f32))))
+
+    ;; Not the same number of arguments/results
+    (type $func1 (func (param (ref $A) (ref $A)) (result (ref $C))))
+    (type $func2 (sub $func1 (func (param (ref $A) (ref $A)) (result (ref $C) (ref $A)))))
+)`;
+
+wasmFailValidateText(code, typeError);
+
+code =`
+(module
+    (type $A (struct (field i32)))
+    (type $B (sub $A (struct (field i32) (field i32))))
+    (type $C (sub $B (struct (field i32) (field i32) (field i64))))
+    (type $D (sub $B (struct (field i32) (field i32) (field f32))))
+
+    ;; Contravariant result types are invalid
+    (type $func3 (func (param (ref $A) (ref $A)) (result (ref $C))))
+    (type $func4 (sub $func3 (func (param (ref $A) (ref $A)) (result (ref $A)))))
+)`;
+
+wasmFailValidateText(code, typeError);
+
+code =`
+(module
+    (type $A (struct (field i32)))
+    (type $B (sub $A (struct (field i32) (field i32))))
+    (type $C (sub $B (struct (field i32) (field i32) (field i64))))
+    (type $D (sub $B (struct (field i32) (field i32) (field f32))))
+
+    ;; Covariant parameters are invalid
+    (type $func5 (func (param (ref $A) (ref $A)) (result (ref $C))))
+    (type $func6 (sub $func5 (func (param (ref $B) (ref $A)) (result (ref $C)))))
+)`;
+
+wasmFailValidateText(code, typeError);
diff --git a/js/src/jit-test/tests/wasm/gc/global-get.js b/js/src/jit-test/tests/wasm/gc/global-get.js
new file mode 100644
index 0000000000..1409fe39cd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/global-get.js
@@ -0,0 +1,30 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// global.get cannot refer to self or after globals after self
+
+assertErrorMessage(() => wasmEvalText(`(module
+	(global i32 global.get 0)
+)`), WebAssembly.CompileError, /global/);
+
+assertErrorMessage(() => wasmEvalText(`(module
+	(global i32 global.get 1)
+	(global i32 i32.const 0)
+)`), WebAssembly.CompileError, /global/);
+
+// global.get works on previous globals
+
+{
+	let {func, b, c, e} = wasmEvalText(`(module
+		(func $func (export "func"))
+
+		(global $a i32 i32.const 1)
+		(global $b (export "b") i32 global.get $a)
+		(global $c (export "c") i32 global.get $b)
+
+		(global $d funcref ref.func $func)
+		(global $e (export "e") funcref global.get $d)
+	)`).exports;
+	assertEq(b.value, 1);
+	assertEq(c.value, 1);
+	assertEq(e.value, func);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/init-expr.js b/js/src/jit-test/tests/wasm/gc/init-expr.js
new file mode 100644
index 0000000000..b4d0b0950b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/init-expr.js
@@ -0,0 +1,75 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Test wasm::InitExpr GC specific constant expressions
+
+// struct.new and struct.new_default
+
+const { structNew, structNewDefault, structLarge } = wasmEvalText(`(module
+    (type $r (struct (field i32) (field f32)))
+    (type $xxl (struct
+        (field i64) (field f64) (field i64) (field f64)
+        (field i64) (field f64) (field i64) (field f64)
+        (field i64) (field f64) (field i64) (field f64)
+        (field i64) (field f64) (field i64) (field f64)
+        (field i64) (field f64) (field i64) (field f64)))
+
+    (global $g1 (ref null $r) (struct.new_default $r))
+
+    (global $g2 (ref null $r) (struct.new $r
+      (i32.const 2)
+      (f32.const 3.14)))
+
+    (global $gx (ref null $xxl) (struct.new $xxl
+      (i64.const 1) (f64.const 2.) (i64.const 3) (f64.const 4.)
+      (i64.const 5) (f64.const 2.) (i64.const 3) (f64.const 4.)
+      (i64.const 1) (f64.const 8.) (i64.const 9) (f64.const 4.)
+      (i64.const 1) (f64.const 2.) (i64.const 12) (f64.const 3.14)
+      (i64.const 16) (f64.const 17.) (i64.const 18) (f64.const 19.)))
+    
+    (func (export "structNewDefault") (result eqref) global.get $g1)
+    (func (export "structNew") (result eqref) global.get $g2)
+    (func (export "structLarge") (result eqref) global.get $gx)
+  )`).exports;
+
+let result;
+result = structNew();
+assertEq(result[0], 2);
+assertEq(result[1], new Float32Array([3.140000104904175])[0]);
+result = structNewDefault();
+assertEq(result[0], 0);
+assertEq(result[1], 0);
+result = structLarge();
+assertEq(result[2], 3n);
+assertEq(result[19], 19);
+
+// array.new, array.new_default, and array.new_fixed
+
+const { arrayNew, arrayNewDefault, arrayNewFixed } = wasmEvalText(`(module
+    (type $r (struct (field i32) (field f32)))
+    (type $a1 (array f64))
+    (type $a2 (array i32))
+    (type $a3 (array (ref null $r)))
+
+    (global $g1 (ref null $a1) (array.new $a1 (f64.const 3.14) (i32.const 3)))
+    (global $g2 (ref null $a2) (array.new_default $a2 (i32.const 2)))
+    (global $g3 (ref null $a3) (array.new_fixed $a3 2
+        (struct.new $r (i32.const 10) (f32.const 16.0))
+        (ref.null $r)))
+
+    (func (export "arrayNew") (result eqref) global.get $g1)
+    (func (export "arrayNewDefault") (result eqref) global.get $g2)
+    (func (export "arrayNewFixed") (result eqref) global.get $g3)
+  )`).exports;
+
+result = arrayNew();
+assertEq(result.length, 3);
+assertEq(result[0], 3.14);
+assertEq(result[2], 3.14);
+result = arrayNewDefault();
+assertEq(result.length, 2);
+assertEq(result[1], 0);
+result = arrayNewFixed();
+assertEq(result.length, 2);
+assertEq(result[0][0], 10);
+assertEq(result[0][1], 16);
+assertEq(result[1], null);
diff --git a/js/src/jit-test/tests/wasm/gc/ion-and-baseline.js b/js/src/jit-test/tests/wasm/gc/ion-and-baseline.js
new file mode 100644
index 0000000000..5a4951c585
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/ion-and-baseline.js
@@ -0,0 +1,88 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Attempt to test intercalls from ion to baseline and back.
+//
+// We get into this situation when the modules are compiled with different
+// tiering policies, or one tiers up before the other, or (for now) one opts
+// into gc and is baseline-compiled and the other does not and is ion-compiled.
+// There are lots of variables here.  Generally, a small module will be
+// ion-compiled unless there's reason to baseline-compile it, so we're likely
+// actually testing something here.
+//
+// Some logging with printf confirms that refmod is baseline-compiled and
+// nonrefmod is ion-compiled at present, with --wasm-gc enabled.
+
+var refmod = new WebAssembly.Module(wasmTextToBinary(
+    `(module
+      (import "" "tbl" (table $tbl 4 funcref))
+      (import "" "print" (func $print (param i32)))
+
+      ;; Just a dummy
+      (type $s (struct (field i32)))
+
+      (type $htype (func (param externref)))
+      (type $itype (func (result externref)))
+
+      (elem (i32.const 0) $f $g)
+
+      (func $f (param externref)
+       (call $print (i32.const 1)))
+
+      (func $g (result externref)
+       (call $print (i32.const 2))
+       (ref.null extern))
+
+      (func (export "test_h")
+       (call_indirect (type $htype) (ref.null extern) (i32.const 2)))
+
+      (func (export "test_i")
+       (drop (call_indirect (type $itype) (i32.const 3))))
+
+     )`));
+
+var nonrefmod = new WebAssembly.Module(wasmTextToBinary(
+    `(module
+      (import "" "tbl" (table $tbl 4 funcref))
+      (import "" "print" (func $print (param i32)))
+
+      (type $ftype (func (param i32)))
+      (type $gtype (func (result i32)))
+
+      (elem (i32.const 2) $h $i)
+
+      ;; Should fail because of the signature mismatch: parameter
+      (func (export "test_f")
+       (call_indirect (type $ftype) (i32.const 37) (i32.const 0)))
+
+      ;; Should fail because of the signature mismatch: return value
+      (func (export "test_g")
+       (drop (call_indirect (type $gtype) (i32.const 1))))
+
+      (func $h (param i32)
+       (call $print (i32.const 2)))
+
+      (func $i (result i32)
+       (call $print (i32.const 3))
+       (i32.const 37))
+     )`));
+
+var tbl = new WebAssembly.Table({initial:4, element:"anyfunc"});
+var refins = new WebAssembly.Instance(refmod, {"":{print, tbl}}).exports;
+var nonrefins = new WebAssembly.Instance(nonrefmod, {"":{print, tbl}}).exports;
+
+assertErrorMessage(() => nonrefins.test_f(),
+                   WebAssembly.RuntimeError,
+                   /indirect call signature mismatch/);
+
+assertErrorMessage(() => nonrefins.test_g(),
+                   WebAssembly.RuntimeError,
+                   /indirect call signature mismatch/);
+
+assertErrorMessage(() => refins.test_h(),
+                   WebAssembly.RuntimeError,
+                   /indirect call signature mismatch/);
+
+assertErrorMessage(() => refins.test_i(),
+                   WebAssembly.RuntimeError,
+                   /indirect call signature mismatch/);
+
diff --git a/js/src/jit-test/tests/wasm/gc/js-boundary.js b/js/src/jit-test/tests/wasm/gc/js-boundary.js
new file mode 100644
index 0000000000..ebf5387704
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/js-boundary.js
@@ -0,0 +1,107 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Tests of dynamic type checks
+test('anyref', WasmAnyrefValues, WasmNonAnyrefValues);
+test('eqref', WasmEqrefValues, WasmNonAnyrefValues);
+test('structref', WasmStructrefValues, WasmNonAnyrefValues);
+test('arrayref', WasmArrayrefValues, WasmNonAnyrefValues);
+let { newStruct } = wasmEvalText(`
+  (module
+    (type $s (struct))
+    (func (export "newStruct") (result anyref)
+        struct.new $s)
+  )`).exports;
+test('(ref null 0)', [newStruct()], WasmNonAnyrefValues, '(type (struct))');
+test('nullref', [null], WasmNonAnyrefValues);
+
+function test(type, validValues, invalidValues, typeSection) {
+  const CheckError = /can only pass|bad type/;
+
+  if (!typeSection) {
+    typeSection = "";
+  }
+
+  // 1. Exported function params
+  let {a} = wasmEvalText(`(module
+    ${typeSection}
+    (func (export "a") (param ${type}))
+  )`).exports;
+  for (let val of invalidValues) {
+    assertErrorMessage(() => a(val), TypeError, CheckError);
+  }
+  for (let val of validValues) {
+    a(val);
+  }
+
+  // 2. Imported function results
+  for (let val of invalidValues) {
+    function returnVal() {
+      return val;
+    }
+    let {test} = wasmEvalText(`(module
+      ${typeSection}
+      (func $returnVal (import "" "returnVal") (result ${type}))
+      (func (export "test")
+        call $returnVal
+        drop
+      )
+    )`, {"": {returnVal}}).exports;
+    assertErrorMessage(() => test(), TypeError, CheckError);
+  }
+  for (let val of validValues) {
+    function returnVal() {
+      return val;
+    }
+    let {test} = wasmEvalText(`(module
+      ${typeSection}
+      (func $returnVal (import "" "returnVal") (result ${type}))
+      (func (export "test")
+        call $returnVal
+        drop
+      )
+    )`, {"": {returnVal}}).exports;
+    test(val);
+  }
+
+  // TODO: the rest of the tests cannot handle type sections yet.
+  if (typeSection !== "") {
+    return;
+  }
+
+  // 3. Global value setter
+  for (let val of validValues) {
+    // Construct global from JS-API with initial value
+    let a = new WebAssembly.Global({value: type}, val);
+    assertEq(a.value, val, 'roundtrip matches');
+
+    // Construct global from JS-API with null value, then set
+    let b = new WebAssembly.Global({value: type, mutable: true}, null);
+    b.value = val;
+    assertEq(b.value, val, 'roundtrip matches');
+  }
+  for (let val of invalidValues) {
+    // Construct global from JS-API with initial value
+    assertErrorMessage(() => new WebAssembly.Global({value: type}, val),
+      TypeError,
+      CheckError);
+
+    // Construct global from JS-API with null value, then set
+    let a = new WebAssembly.Global({value: type, mutable: true}, null);
+    assertErrorMessage(() => a.value = val,
+      TypeError,
+      CheckError);
+  }
+
+  // 4. Table set method
+  for (let val of validValues) {
+    let table = new WebAssembly.Table({element: type, initial: 1, maximum: 1});
+    table.set(0, val);
+    assertEq(table.get(0), val, 'roundtrip matches');
+  }
+  for (let val of invalidValues) {
+    let table = new WebAssembly.Table({element: type, initial: 1, maximum: 1});
+    assertErrorMessage(() => table.set(0, val),
+      TypeError,
+      CheckError);
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/gc/linking.js b/js/src/jit-test/tests/wasm/gc/linking.js
new file mode 100644
index 0000000000..586011219a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/linking.js
@@ -0,0 +1,72 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+function linkGlobals(typeSection, exportInit, linkType) {
+    let {global} = wasmEvalText(`(module
+        ${typeSection}
+        (global (export "global") ${linkType} ${exportInit})
+    )`).exports;
+
+    wasmEvalText(`(module
+        ${typeSection}
+        (import "" "global"
+            (global ${linkType})
+        )
+    )`, {"": {global}});
+}
+
+function linkTables(typeSection, exportInit, linkType) {
+    let {table} = wasmEvalText(`(module
+        ${typeSection}
+        (table (export "table") ${linkType} (elem (${exportInit})))
+    )`).exports;
+
+    wasmEvalText(`(module
+        ${typeSection}
+        (import "" "table"
+            (table 0 1 ${linkType})
+        )
+    )`, {"": {table}});
+}
+
+function linkFuncs(typeSection, exportInit, linkType) {
+    let {func} = wasmEvalText(`(module
+        ${typeSection}
+        (func
+            (export "func")
+            (param ${linkType})
+            (result ${linkType})
+            unreachable
+        )
+    )`).exports;
+
+    wasmEvalText(`(module
+        ${typeSection}
+        (import "" "func"
+            (func (param ${linkType}) (result ${linkType}))
+        )
+    )`, {"": {func}});
+}
+
+const TESTS = [
+    [
+        "(type (struct (field i32)))",
+        "ref.null 0",
+        "(ref null 0)",
+    ],
+    [
+        "(type (array i32))",
+        "ref.null 0",
+        "(ref null 0)",
+    ],
+    [
+        "(type (struct (field i32))) (type (struct (field (ref 0))))",
+        "ref.null 1",
+        "(ref null 1)",
+    ]
+];
+
+for (let test of TESTS) {
+    linkGlobals(...test);
+    linkTables(...test);
+    linkFuncs(...test);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/ref-eq.js b/js/src/jit-test/tests/wasm/gc/ref-eq.js
new file mode 100644
index 0000000000..e266916320
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/ref-eq.js
@@ -0,0 +1,27 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+//
+// ref.eq is part of the gc feature, not the reftypes feature.
+
+let { exports: { make, ref_eq, ref_eq_for_control } } = wasmEvalText(`(module
+    (type $s (struct))
+
+    (func (export "make") (result eqref) struct.new $s)
+
+    (func (export "ref_eq") (param $a eqref) (param $b eqref) (result i32)
+        (ref.eq (local.get $a) (local.get $b)))
+
+    (func (export "ref_eq_for_control") (param $a eqref) (param $b eqref) (result f64)
+        (if (result f64) (ref.eq (local.get $a) (local.get $b))
+            (f64.const 5.0)
+            (f64.const 3.0))))`);
+
+let a = make();
+let b = make();
+
+assertEq(ref_eq(null, null), 1);
+assertEq(ref_eq(null, a), 0);
+assertEq(ref_eq(b, b), 1);
+assertEq(ref_eq_for_control(null, null), 5);
+assertEq(ref_eq_for_control(null, a), 3);
+assertEq(ref_eq_for_control(b, b), 5);
+
diff --git a/js/src/jit-test/tests/wasm/gc/ref-global.js b/js/src/jit-test/tests/wasm/gc/ref-global.js
new file mode 100644
index 0000000000..1e2a87edc6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/ref-global.js
@@ -0,0 +1,96 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Basic private-to-module functionality.  At the moment all we have is null
+// pointers, not very exciting.
+
+{
+    let bin = wasmTextToBinary(
+        `(module
+          (type $point (struct
+                        (field $x f64)
+                        (field $y f64)))
+
+          (global $g1 (mut (ref null $point)) (ref.null $point))
+          (global $g2 (mut (ref null $point)) (ref.null $point))
+          (global $g3 (ref null $point) (ref.null $point))
+
+          ;; Restriction: cannot expose Refs outside the module, not even
+          ;; as a return value.  See ref-restrict.js.
+
+          (func (export "get") (result eqref)
+           (global.get $g1))
+
+          (func (export "copy")
+           (global.set $g2 (global.get $g1)))
+
+          (func (export "clear")
+           (global.set $g1 (global.get $g3))
+           (global.set $g2 (ref.null $point))))`);
+
+    let mod = new WebAssembly.Module(bin);
+    let ins = new WebAssembly.Instance(mod).exports;
+
+    assertEq(ins.get(), null);
+    ins.copy();                 // Should not crash
+    ins.clear();                // Should not crash
+}
+
+// Global with struct type
+
+{
+    let bin = wasmTextToBinary(
+        `(module
+          (type $point (struct
+                        (field $x f64)
+                        (field $y f64)))
+
+          (global $glob (mut (ref null $point)) (ref.null $point))
+
+          (func (export "init")
+           (global.set $glob (struct.new $point (f64.const 0.5) (f64.const 2.75))))
+
+          (func (export "change")
+           (global.set $glob (struct.new $point (f64.const 3.5) (f64.const 37.25))))
+
+          (func (export "clear")
+           (global.set $glob (ref.null $point)))
+
+          (func (export "x") (result f64)
+           (struct.get $point 0 (global.get $glob)))
+
+          (func (export "y") (result f64)
+           (struct.get $point 1 (global.get $glob))))`);
+
+    let mod = new WebAssembly.Module(bin);
+    let ins = new WebAssembly.Instance(mod).exports;
+
+    assertErrorMessage(() => ins.x(), WebAssembly.RuntimeError, /dereferencing null pointer/);
+
+    ins.init();
+    assertEq(ins.x(), 0.5);
+    assertEq(ins.y(), 2.75);
+
+    ins.change();
+    assertEq(ins.x(), 3.5);
+    assertEq(ins.y(), 37.25);
+
+    ins.clear();
+    assertErrorMessage(() => ins.x(), WebAssembly.RuntimeError, /dereferencing null pointer/);
+}
+
+// Global value of type externref for initializer from a WebAssembly.Global,
+// just check that it works.
+{
+    let bin = wasmTextToBinary(
+        `(module
+          (import "" "g" (global $g externref))
+          (global $glob externref (global.get $g))
+          (func (export "get") (result externref)
+           (global.get $glob)))`);
+
+    let mod = new WebAssembly.Module(bin);
+    let obj = {zappa:37};
+    let g = new WebAssembly.Global({value: "externref"}, obj);
+    let ins = new WebAssembly.Instance(mod, {"":{g}}).exports;
+    assertEq(ins.get(), obj);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/ref-struct.js b/js/src/jit-test/tests/wasm/gc/ref-struct.js
new file mode 100644
index 0000000000..59376ac1e7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/ref-struct.js
@@ -0,0 +1,328 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// We'll be running some binary-format tests shortly.
+
+load(libdir + "wasm-binary.js");
+
+const v2vSigSection = sigSection([{args:[], ret:VoidCode}]);
+
+function checkInvalid(body, errorMessage) {
+    assertErrorMessage(() => new WebAssembly.Module(
+        moduleWithSections([v2vSigSection,
+                            declSection([0]),
+                            bodySection([body])])),
+                       WebAssembly.CompileError,
+                       errorMessage);
+}
+
+// General test case for struct.new, struct.get, and struct.set: binary tree
+// manipulation.
+
+{
+    let bin = wasmTextToBinary(
+        `(module
+          (import "" "print_lp" (func $print_lp))
+          (import "" "print_rp" (func $print_rp))
+          (import "" "print_int" (func $print_int (param i32)))
+
+          (type $wabbit (struct
+                         (field $x (mut i32))
+                         (field $left (mut (ref null $wabbit)))
+                         (field $right (mut (ref null $wabbit)))))
+
+          (global $g (mut (ref null $wabbit)) (ref.null $wabbit))
+
+          (global $k (mut i32) (i32.const 0))
+
+          (func (export "init") (param $n i32)
+                (global.set $g (call $make (local.get $n))))
+
+          (func $make (param $n i32) (result (ref null $wabbit))
+                (local $tmp i32)
+                (local.set $tmp (global.get $k))
+                (global.set $k (i32.add (local.get $tmp) (i32.const 1)))
+                (if (result (ref null $wabbit)) (i32.le_s (local.get $n) (i32.const 2))
+                    (struct.new $wabbit (local.get $tmp) (ref.null $wabbit) (ref.null $wabbit))
+                    (block (result (ref null $wabbit))
+                      (struct.new $wabbit
+                                  (local.get $tmp)
+                                  (call $make (i32.sub (local.get $n) (i32.const 1)))
+                                  (call $make (i32.sub (local.get $n) (i32.const 2)))))))
+
+          (func (export "accumulate") (result i32)
+                (call $accum (global.get $g)))
+
+          (func $accum (param $w (ref null $wabbit)) (result i32)
+                (if (result i32) (ref.is_null (local.get $w))
+                    (i32.const 0)
+                    (i32.add (struct.get $wabbit 0 (local.get $w))
+                             (i32.sub (call $accum (struct.get $wabbit 1 (local.get $w)))
+                                      (call $accum (struct.get $wabbit 2 (local.get $w)))))))
+
+          (func (export "reverse")
+                (call $reverse (global.get $g)))
+
+          (func $reverse (param $w (ref null $wabbit))
+                (local $tmp (ref null $wabbit))
+                (if (i32.eqz (ref.is_null (local.get $w)))
+                    (block
+                     (struct.set $wabbit 0 (local.get $w) (i32.mul (i32.const 2) (struct.get $wabbit 0 (local.get $w))))
+                     (local.set $tmp (struct.get $wabbit 1 (local.get $w)))
+                     (struct.set $wabbit 1 (local.get $w) (struct.get $wabbit 2 (local.get $w)))
+                     (struct.set $wabbit 2 (local.get $w) (local.get $tmp))
+                     (call $reverse (struct.get $wabbit 1 (local.get $w)))
+                     (call $reverse (struct.get $wabbit 2 (local.get $w))))))
+
+          (func (export "print")
+                (call $pr (global.get $g)))
+
+          (func $pr (param $w (ref null $wabbit))
+                (if (i32.eqz (ref.is_null (local.get $w)))
+                    (block
+                     (call $print_lp)
+                     (call $print_int (struct.get $wabbit 0 (local.get $w)))
+                     (call $pr (struct.get $wabbit 1 (local.get $w)))
+                     (call $pr (struct.get $wabbit 2 (local.get $w)))
+                     (call $print_rp))))
+         )`);
+
+    let s = "";
+    function pr_int(k) { s += k + " "; }
+    function pr_lp() { s += "(" };
+    function pr_rp() { s += ")" }
+
+    let mod = new WebAssembly.Module(bin);
+    let ins = new WebAssembly.Instance(mod, {"":{print_int:pr_int,print_lp:pr_lp,print_rp:pr_rp}}).exports;
+
+    ins.init(6);
+    s = ""; ins.print(); assertEq(s, "(0 (1 (2 (3 (4 )(5 ))(6 ))(7 (8 )(9 )))(10 (11 (12 )(13 ))(14 )))");
+    assertEq(ins.accumulate(), -13);
+
+    ins.reverse();
+    s = ""; ins.print(); assertEq(s, "(0 (20 (28 )(22 (26 )(24 )))(2 (14 (18 )(16 ))(4 (12 )(6 (10 )(8 )))))");
+    assertEq(ins.accumulate(), 14);
+
+    for (let i=10; i < 22; i++ ) {
+        ins.init(i);
+        ins.reverse();
+        gc();
+        ins.reverse();
+    }
+}
+
+// Sanity check for struct.set: we /can/ store a (ref null T) into a (ref null U) field
+// with struct.set if T <: U; this should fall out of normal coercion but good
+// to test.
+
+wasmEvalText(
+    `(module
+      (type $node (struct (field (mut (ref null $node)))))
+      (type $nix (sub $node (struct (field (mut (ref null $node))) (field i32))))
+      (func $f (param $p (ref null $node)) (param $q (ref null $nix))
+       (struct.set $node 0 (local.get $p) (local.get $q))))`);
+
+// ref.cast: if the pointer is null we trap
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field i32)))
+      (type $node2 (struct (field i32) (field f32)))
+      (func $f (param $p (ref null $node)) (result (ref null $node2))
+       (ref.cast (ref $node2) (local.get $p)))
+      (func (export "test") (result eqref)
+       (call $f (ref.null $node))))`).exports.test(),
+    WebAssembly.RuntimeError,
+    /bad cast/,
+);
+
+// ref.cast null: if the pointer is null we do not trap
+
+wasmEvalText(
+  `(module
+    (type $node (struct (field i32)))
+    (type $node2 (struct (field i32) (field f32)))
+    (func $f (param $p (ref null $node)) (result (ref null $node2))
+     (ref.cast (ref null $node2) (local.get $p)))
+    (func (export "test") (result eqref)
+     (call $f (ref.null $node))))`).exports.test();
+
+// ref.cast: if the downcast succeeds we get the original pointer
+
+assertEq(wasmEvalText(
+    `(module
+      (type $node (struct (field i32)))
+      (type $node2 (sub $node (struct (field i32) (field f32))))
+      (func $f (param $p (ref null $node)) (result (ref null $node2))
+       (ref.cast (ref null $node2) (local.get $p)))
+      (func (export "test") (result i32)
+       (local $n (ref null $node))
+       (local.set $n (struct.new $node2 (i32.const 0) (f32.const 12)))
+       (ref.eq (call $f (local.get $n)) (local.get $n))))`).exports.test(),
+         1);
+
+// And once more with mutable fields
+
+assertEq(wasmEvalText(
+    `(module
+      (type $node (struct (field (mut i32))))
+      (type $node2 (sub $node (struct (field (mut i32)) (field f32))))
+      (func $f (param $p (ref null $node)) (result (ref null $node2))
+       (ref.cast (ref null $node2) (local.get $p)))
+      (func (export "test") (result i32)
+       (local $n (ref null $node))
+       (local.set $n (struct.new $node2 (i32.const 0) (f32.const 12)))
+       (ref.eq (call $f (local.get $n)) (local.get $n))))`).exports.test(),
+         1);
+
+// ref.cast: eqref -> struct when the eqref is the right struct;
+// special case since eqref requires unboxing
+
+assertEq(wasmEvalText(
+    `(module
+      (type $node (struct (field i32)))
+      (func $f (param $p eqref) (result (ref null $node))
+       (ref.cast (ref null $node) (local.get $p)))
+      (func (export "test") (result i32)
+       (local $n (ref null $node))
+       (local.set $n (struct.new $node (i32.const 0)))
+       (ref.eq (call $f (local.get $n)) (local.get $n))))`).exports.test(),
+         1);
+
+// Can default initialize a struct which zero initializes
+
+{
+  let {makeA, makeB, makeC} = wasmEvalText(`
+  (module
+   (type $a (struct))
+   (type $b (struct (field i32) (field f32)))
+   (type $c (struct (field eqref)))
+
+   (func (export "makeA") (result eqref)
+     struct.new_default $a
+   )
+   (func (export "makeB") (result eqref)
+     struct.new_default $b
+   )
+   (func (export "makeC") (result eqref)
+     struct.new_default $c
+   )
+  )`).exports;
+  let a = makeA();
+
+  let b = makeB();
+  assertEq(b[0], 0);
+  assertEq(b[1], 0);
+
+  let c = makeC();
+  assertEq(c[0], null);
+}
+
+// struct.new_default: valid if all struct fields are defaultable
+
+wasmFailValidateText(`(module
+  (type $a (struct (field (ref $a))))
+  (func
+    struct.new_default $a
+  )
+)`, /defaultable/);
+
+wasmFailValidateText(`(module
+  (type $a (struct (field i32) (field i32) (field (ref $a))))
+  (func
+    struct.new_default $a
+  )
+)`, /defaultable/);
+
+// Negative tests
+
+// Attempting to mutate immutable field with struct.set
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field i32)))
+      (func $f (param $p (ref null $node))
+       (struct.set $node 0 (local.get $p) (i32.const 37))))`),
+                   WebAssembly.CompileError,
+                   /field is not mutable/);
+
+// Attempting to store incompatible value in mutable field with struct.set
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field (mut i32))))
+      (func $f (param $p (ref null $node))
+       (struct.set $node 0 (local.get $p) (f32.const 37))))`),
+                   WebAssembly.CompileError,
+                   /expression has type f32 but expected i32/);
+
+// Out-of-bounds reference for struct.get
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field i32)))
+      (func $f (param $p (ref null $node)) (result i32)
+       (struct.get $node 1 (local.get $p))))`),
+                   WebAssembly.CompileError,
+                   /field index out of range/);
+
+// Out-of-bounds reference for struct.set
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field (mut i32))))
+      (func $f (param $p (ref null $node))
+       (struct.set $node 1 (local.get $p) (i32.const 37))))`),
+                   WebAssembly.CompileError,
+                   /field index out of range/);
+
+// Base pointer is of unrelated type to stated type in struct.get
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field i32)))
+      (type $snort (struct (field f64)))
+      (func $f (param $p (ref null $snort)) (result i32)
+       (struct.get $node 0 (local.get $p))))`),
+                   WebAssembly.CompileError,
+                   /expression has type.*but expected.*/);
+
+// Base pointer is of unrelated type to stated type in struct.set
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (type $node (struct (field (mut i32))))
+      (type $snort (struct (field f64)))
+      (func $f (param $p (ref null $snort)) (result i32)
+       (struct.set $node 0 (local.get $p) (i32.const 0))))`),
+                   WebAssembly.CompileError,
+                   /expression has type.*but expected.*/);
+
+// Null pointer dereference in struct.get
+
+assertErrorMessage(function() {
+    let ins = wasmEvalText(
+        `(module
+          (type $node (struct (field i32)))
+          (func (export "test")
+           (drop (call $f (ref.null $node))))
+          (func $f (param $p (ref null $node)) (result i32)
+           (struct.get $node 0 (local.get $p))))`);
+    ins.exports.test();
+},
+                   WebAssembly.RuntimeError,
+                   /dereferencing null pointer/);
+
+// Null pointer dereference in struct.set
+
+assertErrorMessage(function() {
+    let ins = wasmEvalText(
+        `(module
+          (type $node (struct (field (mut i32))))
+          (func (export "test")
+           (call $f (ref.null $node)))
+          (func $f (param $p (ref null $node))
+           (struct.set $node 0 (local.get $p) (i32.const 0))))`);
+    ins.exports.test();
+},
+                   WebAssembly.RuntimeError,
+                   /dereferencing null pointer/);
diff --git a/js/src/jit-test/tests/wasm/gc/ref.js b/js/src/jit-test/tests/wasm/gc/ref.js
new file mode 100644
index 0000000000..30f5413029
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/ref.js
@@ -0,0 +1,202 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Parsing and resolving.
+
+var text = `(module
+      (rec
+        (type $cons (struct
+                     (field $car i32)
+                     (field $cdr (ref null $cons))))
+
+        (type $odd (struct
+                    (field $odd.x i32)
+                    (field $to_even (ref null $even))))
+
+        (type $even (struct
+                     (field $even.x i32)
+                     (field $to_odd (ref null $odd))))
+      )
+
+      ;; Use eqref on the API since struct types cannot be exposed outside the module yet.
+
+      (import "m" "f" (func $imp (param eqref) (result eqref)))
+
+      ;; The bodies do nothing since we have no operations on structs yet.
+      ;; Note none of these functions are exported, as they use Ref types in their signatures.
+
+      (func (param (ref null $cons)) (result i32)
+       (i32.const 0))
+
+      (func $cdr (param $p (ref null $cons)) (result (ref null $cons))
+       (local $l (ref null $cons))
+       ;; store null value of correct type
+       (local.set $l (ref.null $cons))
+       ;; store local of correct type
+       (local.set $l (local.get $p))
+       ;; store call result of correct type
+       (local.set $l (call $cdr (local.get $p)))
+       ;; TODO: eventually also a test with global.get
+       ;; blocks and if with result type
+       (block (result (ref null $cons))
+        (if (result (ref null $cons)) (i32.eqz (i32.const 0))
+            (unreachable)
+            (ref.null $cons))))
+
+      (func (param (ref null $even)) (result (ref null $odd))
+       (ref.null $odd))
+
+      (func (param (ref null $odd)) (result (ref null $even))
+       (ref.null $even))
+
+      (func (param (ref null $cons))
+       (call $cdr (local.get 0))
+       drop
+       (call $imp (local.get 0))
+       drop)
+
+      (func (param (ref null $cons))
+       (drop (ref.eq (local.get 0) (ref.null $cons)))
+       (drop (ref.eq (ref.null $cons) (local.get 0)))
+       (drop (ref.eq (local.get 0) (ref.null $cons)))
+       (drop (ref.eq (ref.null $cons) (local.get 0))))
+     )`;
+
+// Validation
+
+wasmValidateText(text);
+
+// ref.is_null should work on any reference type
+
+new WebAssembly.Module(wasmTextToBinary(`
+(module
+ (type $s (struct))
+ (func $null (param (ref null $s)) (result i32)
+   (ref.is_null (local.get 0))))
+`))
+
+// Automatic upcast to eqref
+
+new WebAssembly.Module(wasmTextToBinary(`
+(module
+ (type $s (struct (field i32)))
+ (func $f (param (ref null $s)) (call $g (local.get 0)))
+ (func $g (param eqref) (unreachable)))
+`));
+
+// Misc failure modes
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (func (param (ref null $odd)) (unreachable)))
+`),
+SyntaxError, /failed to find name/);
+
+// Ref type mismatch in parameter is allowed through the prefix rule
+// but not if the structs are incompatible.
+
+wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field i32)))
+ (func $f (param (ref null $s)) (unreachable))
+ (func $g (param (ref null $t)) (call $f (local.get 0)))
+)`);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field f32))) ;; Incompatible type
+ (func $f (param (ref null $s)) (unreachable))
+ (func $g (param (ref null $t)) (call $f (local.get 0)))
+)`),
+WebAssembly.CompileError, /expression has type \(ref null.*\) but expected \(ref null.*\)/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field (mut i32)))) ;; Incompatible mutability
+ (func $f (param (ref null $s)) (unreachable))
+ (func $g (param (ref null $t)) (call $f (local.get 0)))
+)`),
+WebAssembly.CompileError, /expression has type \(ref null.*\) but expected \(ref null.*\)/);
+
+// Ref type mismatch in assignment to local but the prefix rule allows
+// the assignment to succeed if the structs are the same.
+
+wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field i32)))
+ (func $f (param (ref null $s)) (local (ref null $t)) (local.set 1 (local.get 0))))
+`)
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field f32)))
+ (func $f (param (ref null $s)) (local (ref null $t)) (local.set 1 (local.get 0))))
+`),
+WebAssembly.CompileError, /expression has type \(ref null.*\) but expected \(ref null.*\)/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field (mut i32))))
+ (func $f (param (ref null $s)) (unreachable))
+ (func $g (param (ref null $t)) (call $f (local.get 0)))
+)`),
+WebAssembly.CompileError, /expression has type \(ref null.*\) but expected \(ref null.*\)/);
+
+// Ref type mismatch in return but the prefix rule allows the return
+// to succeed if the structs are the same.
+
+wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field i32)))
+ (func $f (param (ref null $s)) (result (ref null $t)) (local.get 0)))
+`);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field f32)))
+ (func $f (param (ref null $s)) (result (ref null $t)) (local.get 0)))
+`),
+WebAssembly.CompileError, /expression has type \(ref null.*\) but expected \(ref null.*\)/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (type $t (struct (field (mut i32))))
+ (func $f (param (ref null $s)) (result (ref null $t)) (local.get 0)))
+`),
+WebAssembly.CompileError, /expression has type \(ref null.*\) but expected \(ref null.*\)/);
+
+if (!wasmFunctionReferencesEnabled()) {
+  // Ref type can't reference a function type
+
+  assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $x (func (param i32)))
+ (func $f (param (ref null $x)) (unreachable)))
+`),
+  WebAssembly.CompileError, /does not reference a gc type/);
+
+  assertErrorMessage(() => wasmEvalText(`
+(module
+ (type (func (param i32)))
+ (func $f (param (ref null 0)) (unreachable)))
+`),
+  WebAssembly.CompileError, /does not reference a gc type/);
+}
+
+// No automatic downcast from eqref
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field i32)))
+ (func $f (param eqref) (call $g (local.get 0)))
+ (func $g (param (ref null $s)) (unreachable)))
+`),
+WebAssembly.CompileError, /expression has type eqref but expected \(ref null.*\)/);
diff --git a/js/src/jit-test/tests/wasm/gc/regress-1633355.js b/js/src/jit-test/tests/wasm/gc/regress-1633355.js
new file mode 100644
index 0000000000..97c611efd8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/regress-1633355.js
@@ -0,0 +1,30 @@
+// |jit-test| skip-if: !wasmGcEnabled() || wasmCompileMode().includes("ion")
+
+load(libdir + "asserts.js");
+
+var g23 = newGlobal({newCompartment: true});
+g23.parent = this;
+g23.eval(`
+    var dbg = new Debugger(parent);
+    dbg.onEnterFrame = function(frame) {}
+`);
+let bin = wasmTextToBinary(`
+     (type $wabbit (struct
+        (field $x (mut i32))
+        (field $left (mut (ref null $wabbit)))
+        (field $right (mut (ref null $wabbit)))
+     ))
+     (global $g (mut (ref null $wabbit)) (ref.null $wabbit))
+     (func (export "init") (param $n i32)
+       (global.set $g (call $make (local.get $n)))
+     )
+     (func $make (param $n i32) (result (ref null $wabbit))
+       (local $tmp i32)
+       (struct.new $wabbit (local.get $tmp) (ref.null $wabbit) (ref.null $wabbit))
+     )
+`);
+let mod = new WebAssembly.Module(bin);
+let ins = new WebAssembly.Instance(mod).exports;
+
+// Debugger can handle non-exposable fields, like (ref T).
+ins.init(6)
diff --git a/js/src/jit-test/tests/wasm/gc/regress-1739330.js b/js/src/jit-test/tests/wasm/gc/regress-1739330.js
new file mode 100644
index 0000000000..99e519d2d9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/regress-1739330.js
@@ -0,0 +1,23 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+try {
+  gczeal(4);
+  function a(b) {
+    binary = wasmTextToBinary(b)
+    c = new WebAssembly.Module(binary)
+    return new WebAssembly.Instance(c)
+  }
+  d = [];
+  let { newStruct } = a(`
+    (type $e (struct))
+      (func (export "newStruct")
+        (result eqref)
+        struct.new $e
+      )
+  `).exports
+  d.push(newStruct());
+  gczeal(14, 7);
+  throw d;
+} catch (d) {
+  assertEq(d instanceof Array, true);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/regress-1745391.js b/js/src/jit-test/tests/wasm/gc/regress-1745391.js
new file mode 100644
index 0000000000..5ea8989d3e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/regress-1745391.js
@@ -0,0 +1,13 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+let { createDefault } = wasmEvalText(`
+  (module (type $a (array (mut i32)))
+    (func (export "createDefault") (param i32) (result eqref)
+      local.get 0
+      array.new_default $a
+    )
+  )
+`).exports;
+for (len = -1; len > -100; len--) {
+  assertErrorMessage(() => createDefault(len), WebAssembly.RuntimeError, /too many array elements/);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/regress-1754701.js b/js/src/jit-test/tests/wasm/gc/regress-1754701.js
new file mode 100644
index 0000000000..656aa5d625
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/regress-1754701.js
@@ -0,0 +1,30 @@
+// |jit-test| skip-if: !wasmGcEnabled() || !('oomTest' in this)
+
+let { testArray, testStructInline, testStructOutline } = wasmEvalText(`
+  (module
+  (type $array (array i32))
+  (type $structInline (struct))
+  (type $structOutline
+    (struct
+      ${`(field i32)`.repeat(100)}
+    )
+  )
+  (func (export "testArray")
+    (param i32)
+    (result eqref)
+    local.get 0
+    array.new_default $array
+  )
+  (func (export "testStructInline")
+    (result eqref)
+    struct.new_default $structInline
+  )
+  (func (export "testStructOutline")
+    (result eqref)
+    struct.new_default $structOutline
+  )
+ )
+`).exports
+oomTest(() => testArray(1));
+oomTest(() => testStructInline());
+oomTest(() => testStructOutline());
diff --git a/js/src/jit-test/tests/wasm/gc/regress-1830975.js b/js/src/jit-test/tests/wasm/gc/regress-1830975.js
new file mode 100644
index 0000000000..ae6cba6bdd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/regress-1830975.js
@@ -0,0 +1,17 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Hello, future wasm dev. This test will start failing when you add casting
+// for func and extern types. When that happens, remove the assertErrorMessage.
+
+assertErrorMessage(() => {
+  const { test } = wasmEvalText(`
+    (module
+      (type $f (func (result i32)))
+      (func (export "test") (type $f)
+        ref.null $f
+        ref.test (ref null $f)
+      )
+    )
+  `).exports;
+  assertEq(test(), 1);
+}, WebAssembly.CompileError, /ref.test only supports the any hierarchy/);
diff --git a/js/src/jit-test/tests/wasm/gc/regress-outline-repr.js b/js/src/jit-test/tests/wasm/gc/regress-outline-repr.js
new file mode 100644
index 0000000000..f49b6480df
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/regress-outline-repr.js
@@ -0,0 +1,151 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// White-box test for bug 1617908.  The significance of this test is that the
+// type $S is too large to fit in an inline TypedObject, and the write barrier
+// logic must take this into account when storing the (ref $S2) into the last
+// field of the object.
+
+const wat = `
+(module
+  (type $S2 (struct))
+  (type $S (sub $S2
+    (struct
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut eqref)))))
+
+  (func $main
+    (struct.set $S 18
+      (struct.new $S
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (i64.const 0)
+        (ref.null eq))
+      (struct.new $S2)))
+  (start $main))
+`
+wasmEvalText(wat);
+
+// Test subtyping across outline/inline representations works
+
+wasmEvalText(`
+(module
+  (type $inline
+    (struct
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+    ))
+  (type $outline (sub $inline
+    (struct
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64))
+      (field (mut i64)))))
+  
+  (func $main
+    (local $outline (ref null $outline))
+    (local $inline (ref null $inline))
+
+    (; create an outline object and acquire multiple views to it ;)
+    (struct.new $outline
+          (i64.const 0xFF)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0)
+          (i64.const 0))
+    local.tee $outline
+    local.set $inline
+
+    (; clobber the object header ;)
+    (struct.set $inline 0
+      local.get $inline
+      i64.const 0
+    )
+    (struct.set $inline 1
+      local.get $inline
+      i64.const 0
+    )
+    (struct.set $inline 2
+      local.get $inline
+      i64.const 0
+    )
+    (struct.set $inline 3
+      local.get $inline
+      i64.const 0
+    )
+    (struct.set $inline 4
+      local.get $inline
+      i64.const 0
+    )
+
+    (; try to read a field ;)
+    (struct.get $outline 0
+      local.get $outline
+    )
+    drop
+  )
+  (start $main))
+`);
diff --git a/js/src/jit-test/tests/wasm/gc/signal-null-check.js b/js/src/jit-test/tests/wasm/gc/signal-null-check.js
new file mode 100644
index 0000000000..a56526031d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/signal-null-check.js
@@ -0,0 +1,148 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+//
+// Checks if null dereference works.
+
+for (let [fieldType, signedness, defaultValue] of [
+  ['i8', '_u', 'i32.const 42'],
+  ['i8', '_s', 'i32.const -42'],
+  ['i16', '_u', 'i32.const 1'],
+  ['i16', '_s', 'i32.const -1'],
+  ['i32', '', 'i32.const 3'],
+  ['i64', '', 'i64.const -77777777777'],
+  ['f32', '', 'f32.const 1.4'],
+  ['f64', '', 'f64.const 3.14'],
+  ['externref', '', 'ref.null extern'],
+].concat(
+  wasmSimdEnabled() ? [['v128', '', 'v128.const i32x4 1 2 -3 4']] : []
+)) {
+  // Check struct.get from null struct of a field of fieldType works
+  // Check struct.set similarly
+  testStructGetSet(fieldType, signedness, defaultValue, 4);
+  //   - Also when the field is in the outline_ data area?
+  testStructGetSet(fieldType, signedness, defaultValue, 1000);
+  // Check array.get similarly
+  // Check array.set from null array with element of type fieldType
+  testArrayGetSet(fieldType, signedness, defaultValue, 100);
+}
+
+function testStructGetSet(fieldType, signedness, defaultValue, numFields) {
+  const ins = wasmEvalText(`
+(module
+  (type $t (struct ${
+      Array(numFields).fill("(field (mut " + fieldType + "))").join(' ')
+  }))
+  (global $g (mut (ref null $t)) (ref.null $t))
+  (func (export "init-null")
+    ref.null $t
+    global.set $g
+  )
+  (func (export "init-non-null")
+    ${ Array(numFields).fill(defaultValue).join('\n    ') }
+    struct.new $t
+    global.set $g
+  )
+  (func (export "test_get_first")
+    global.get $g
+    struct.get${signedness} $t 0
+    drop
+  )
+  (func (export "test_set_first")
+    global.get $g
+    ${defaultValue}
+    struct.set $t 0
+  )
+  (func (export "test_get_mid")
+    global.get $g
+    struct.get${signedness} $t ${numFields >> 1}
+    drop
+  )
+  (func (export "test_set_mid")
+    global.get $g
+    ${defaultValue}
+    struct.set $t ${numFields >> 1}
+  )
+  (func (export "test_get_last")
+    global.get $g
+    struct.get${signedness} $t ${numFields - 1}
+    drop
+  )
+  (func (export "test_set_last")
+    global.get $g
+    ${defaultValue}
+    struct.set $t ${numFields - 1}
+  )
+)`);
+  ins.exports["init-non-null"]();
+  ins.exports["test_get_first"]();
+  ins.exports["test_get_mid"]();
+  ins.exports["test_get_last"]();
+  ins.exports["test_set_first"]();
+  ins.exports["test_set_mid"]();
+  ins.exports["test_set_last"]();
+
+  ins.exports["init-null"]();
+  assertDerefenceNull(() => ins.exports["test_get_first"]());
+  assertDerefenceNull(() => ins.exports["test_get_mid"]());
+  assertDerefenceNull(() => ins.exports["test_get_last"]());
+  assertDerefenceNull(() => ins.exports["test_set_first"]());
+  assertDerefenceNull(() => ins.exports["test_set_mid"]());
+  assertDerefenceNull(() => ins.exports["test_set_last"]());
+
+  ins.exports["init-non-null"]();
+  ins.exports["test_set_last"]();
+  ins.exports["test_get_first"]();
+}
+
+function testArrayGetSet(fieldType, signedness, defaultValue, numItems) {
+  const ins = wasmEvalText(`
+(module
+  (type $t (array (mut ${fieldType})))
+  (global $g (mut (ref null $t)) (ref.null $t))
+  (func (export "init-null")
+    ref.null $t
+    global.set $g
+  )
+  (func (export "init-non-null")
+    ${defaultValue}
+    i32.const ${numItems}
+    array.new $t
+    global.set $g
+  )
+  (func (export "test_get") (param i32)
+    global.get $g
+    local.get 0
+    array.get${signedness} $t
+    drop
+  )
+  (func (export "test_set") (param i32)
+    global.get $g
+    local.get 0
+    ${defaultValue}
+    array.set $t
+  )
+)`);
+  ins.exports["init-non-null"]();
+  ins.exports["test_get"](0);
+  ins.exports["test_get"](numItems >> 1);
+  ins.exports["test_get"](numItems - 1);
+  ins.exports["test_set"](0);
+  ins.exports["test_set"](numItems >> 1);
+  ins.exports["test_set"](numItems - 1);
+
+  ins.exports["init-null"]();
+  assertDerefenceNull(() => ins.exports["test_get"](0));
+  assertDerefenceNull(() => ins.exports["test_get"](numItems >> 1));
+  assertDerefenceNull(() => ins.exports["test_get"](numItems - 1));
+  assertDerefenceNull(() => ins.exports["test_set"](0));
+  assertDerefenceNull(() => ins.exports["test_set"](numItems >> 1));
+  assertDerefenceNull(() => ins.exports["test_set"](numItems - 1));
+
+  ins.exports["init-non-null"]();
+  ins.exports["test_set"](3);
+  ins.exports["test_get"](0);
+}
+
+
+function assertDerefenceNull(fun) {
+  assertErrorMessage(fun, WebAssembly.RuntimeError, /dereferencing null pointer/);
+}
diff --git a/js/src/jit-test/tests/wasm/gc/structs.js b/js/src/jit-test/tests/wasm/gc/structs.js
new file mode 100644
index 0000000000..388541c4ee
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/structs.js
@@ -0,0 +1,724 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// This tests a bunch of wasm struct stuff, but not i8 or i16 fields.
+// See structs2.js for i8/i16 field tests.
+
+var conf = getBuildConfiguration();
+
+var bin = wasmTextToBinary(
+    `(module
+      (func $x1 (import "m" "x1") (type $f1))
+      (func $x2 (import "m" "x2") (type $f2))
+
+      (table 2 funcref)
+      (elem (i32.const 0) $doit $doitagain)
+
+      ;; Type array has a mix of types
+
+      (type $f1 (func (param i32) (result i32)))
+
+      (type $point (struct
+                    (field $point_x i32)
+                    (field $point_y i32)))
+
+      (type $f2 (func (param f64) (result f64)))
+
+      (type $int_node (struct
+                       (field $intbox_val (mut i32))
+                       (field $intbox_next (mut externref))))
+
+      ;; Test all the types.
+
+      (type $omni (struct
+                   (field $omni_i32 i32)
+                   (field $omni_i32m (mut i32))
+                   (field $omni_i64 i64)
+                   (field $omni_i64m (mut i64))
+                   (field $omni_f32 f32)
+                   (field $omni_f32m (mut f32))
+                   (field $omni_f64 f64)
+                   (field $omni_f64m (mut f64))
+                   (field $omni_externref externref)
+                   (field $omni_externrefm (mut externref))))
+
+      ;; Various ways to reference a type in the middle of the
+      ;; type array, make sure we get the right one
+
+      (func (export "hello") (param f64) (param i32) (result f64)
+       (call_indirect (type $f2) (local.get 0) (local.get 1)))
+
+      (func $doit (param f64) (result f64)
+       (f64.sqrt (local.get 0)))
+
+      (func $doitagain (param f64) (result f64)
+       (f64.mul (local.get 0) (local.get 0)))
+
+      (func (export "x1") (param i32) (result i32)
+       (call $x1 (local.get 0)))
+
+      (func (export "x2") (param f64) (result f64)
+       (call $x2 (local.get 0)))
+
+      ;; Useful for testing to ensure that the type is not type #0 here.
+
+      (func (export "mk_point") (result eqref)
+       (struct.new $point (i32.const 37) (i32.const 42)))
+
+      (func (export "mk_int_node") (param i32) (param externref) (result eqref)
+       (struct.new $int_node (local.get 0) (local.get 1)))
+
+      ;; Too big to fit in an InlineTypedObject.
+
+      (type $bigger (struct
+                     (field $a i32)
+                     (field $b i32)
+                     (field $c i32)
+                     (field $d i32)
+                     (field $e i32)
+                     (field $f i32)
+                     (field $g i32)
+                     (field $h i32)
+                     (field $i i32)
+                     (field $j i32)
+                     (field $k i32)
+                     (field $l i32)
+                     (field $m i32)
+                     (field $n i32)
+                     (field $o i32)
+                     (field $p i32)
+                     (field $q i32)
+                     (field $r i32)
+                     (field $s i32)
+                     (field $t i32)
+                     (field $u i32)
+                     (field $v i32)
+                     (field $w i32)
+                     (field $x i32)
+                     (field $y i32)
+                     (field $z i32)
+                     (field $aa i32)
+                     (field $ab i32)
+                     (field $ac i32)
+                     (field $ad i32)
+                     (field $ae i32)
+                     (field $af i32)
+                     (field $ag i32)
+                     (field $ah i32)
+                     (field $ai i32)
+                     (field $aj i32)
+                     (field $ak i32)
+                     (field $al i32)
+                     (field $am i32)
+                     (field $an i32)
+                     (field $ao i32)
+                     (field $ap i32)
+                     (field $aq i32)
+                     (field $ar i32)
+                     (field $as i32)
+                     (field $at i32)
+                     (field $au i32)
+                     (field $av i32)
+                     (field $aw i32)
+                     (field $ax i32)
+                     (field $ay i32)
+                     (field $az i32)))
+
+      (func (export "mk_bigger") (result eqref)
+            (struct.new $bigger
+                       (i32.const 0)
+                       (i32.const 1)
+                       (i32.const 2)
+                       (i32.const 3)
+                       (i32.const 4)
+                       (i32.const 5)
+                       (i32.const 6)
+                       (i32.const 7)
+                       (i32.const 8)
+                       (i32.const 9)
+                       (i32.const 10)
+                       (i32.const 11)
+                       (i32.const 12)
+                       (i32.const 13)
+                       (i32.const 14)
+                       (i32.const 15)
+                       (i32.const 16)
+                       (i32.const 17)
+                       (i32.const 18)
+                       (i32.const 19)
+                       (i32.const 20)
+                       (i32.const 21)
+                       (i32.const 22)
+                       (i32.const 23)
+                       (i32.const 24)
+                       (i32.const 25)
+                       (i32.const 26)
+                       (i32.const 27)
+                       (i32.const 28)
+                       (i32.const 29)
+                       (i32.const 30)
+                       (i32.const 31)
+                       (i32.const 32)
+                       (i32.const 33)
+                       (i32.const 34)
+                       (i32.const 35)
+                       (i32.const 36)
+                       (i32.const 37)
+                       (i32.const 38)
+                       (i32.const 39)
+                       (i32.const 40)
+                       (i32.const 41)
+                       (i32.const 42)
+                       (i32.const 43)
+                       (i32.const 44)
+                       (i32.const 45)
+                       (i32.const 46)
+                       (i32.const 47)
+                       (i32.const 48)
+                       (i32.const 49)
+                       (i32.const 50)
+                       (i32.const 51)))
+
+      (type $withfloats (struct
+                         (field $f1 f32)
+                         (field $f2 f64)
+                         (field $f3 externref)
+                         (field $f4 f32)
+                         (field $f5 i32)))
+
+      (func (export "mk_withfloats")
+            (param f32) (param f64) (param externref) (param f32) (param i32)
+            (result eqref)
+            (struct.new $withfloats (local.get 0) (local.get 1) (local.get 2) (local.get 3) (local.get 4)))
+
+     )`)
+
+var mod = new WebAssembly.Module(bin);
+var ins = new WebAssembly.Instance(mod, {m:{x1(x){ return x*3 }, x2(x){ return Math.PI }}}).exports;
+
+assertEq(ins.hello(4.0, 0), 2.0)
+assertEq(ins.hello(4.0, 1), 16.0)
+
+assertEq(ins.x1(12), 36)
+assertEq(ins.x2(8), Math.PI)
+
+var point = ins.mk_point();
+assertEq(0 in point, true);
+assertEq(1 in point, true);
+assertEq(2 in point, false);
+assertEq(point[0], 37);
+assertEq(point[1], 42);
+
+var int_node = ins.mk_int_node(78, point);
+assertEq(int_node[0], 78);
+assertEq(int_node[1], point);
+
+var bigger = ins.mk_bigger();
+for ( let i=0; i < 52; i++ )
+    assertEq(bigger[i], i);
+
+assertEq(bigger[-1], undefined);
+assertEq(bigger[52], undefined);
+
+var withfloats = ins.mk_withfloats(1/3, Math.PI, bigger, 5/6, 0x1337);
+assertEq(withfloats[0], Math.fround(1/3));
+assertEq(withfloats[1], Math.PI);
+assertEq(withfloats[2], bigger);
+assertEq(withfloats[3], Math.fround(5/6));
+assertEq(withfloats[4], 0x1337);
+
+// A simple stress test
+
+var stress = wasmTextToBinary(
+    `(module
+      (type $node (struct (field i32) (field (ref null $node))))
+      (func (export "iota1") (param $n i32) (result eqref)
+       (local $list (ref null $node))
+       (block $exit
+        (loop $loop
+         (br_if $exit (i32.eqz (local.get $n)))
+         (local.set $list (struct.new $node (local.get $n) (local.get $list)))
+         (local.set $n (i32.sub (local.get $n) (i32.const 1)))
+         (br $loop)))
+       (local.get $list)))`);
+var stressIns = new WebAssembly.Instance(new WebAssembly.Module(stress)).exports;
+var stressLevel = conf.x64 && !conf.tsan && !conf.asan && !conf.valgrind ? 100000 : 1000;
+var the_list = stressIns.iota1(stressLevel);
+for (let i=1; i <= stressLevel; i++) {
+    assertEq(the_list[0], i);
+    the_list = the_list[1];
+}
+assertEq(the_list, null);
+
+// Fields and their exposure in JS.  We can't export types yet so hide them
+// inside the module with globals.
+
+// i64 fields.
+
+{
+    let txt =
+        `(module
+          (type $big (struct
+                      (field (mut i32))
+                      (field (mut i64))
+                      (field (mut i32))))
+
+          (func (export "set") (param eqref)
+           (local (ref null $big))
+           (local.set 1 (ref.cast (ref null $big) (local.get 0)))
+           (struct.set $big 1 (local.get 1) (i64.const 0x3333333376544567)))
+
+          (func (export "set2") (param $p eqref)
+           (struct.set $big 1
+            (ref.cast (ref null $big) (local.get $p))
+            (i64.const 0x3141592653589793)))
+
+          (func (export "low") (param $p eqref) (result i32)
+           (i32.wrap/i64 (struct.get $big 1 (ref.cast (ref null $big) (local.get $p)))))
+
+          (func (export "high") (param $p eqref) (result i32)
+           (i32.wrap/i64 (i64.shr_u
+                          (struct.get $big 1 (ref.cast (ref null $big) (local.get $p)))
+                          (i64.const 32))))
+
+          (func (export "mk") (result eqref)
+           (struct.new $big (i32.const 0x7aaaaaaa) (i64.const 0x4201020337) (i32.const 0x6bbbbbbb)))
+
+         )`;
+
+    let ins = wasmEvalText(txt).exports;
+
+    let v = ins.mk();
+    assertEq(typeof v, "object");
+    assertEq(v[0], 0x7aaaaaaa);
+    assertEq(v[1], 0x4201020337n);
+    assertEq(ins.low(v), 0x01020337);
+    assertEq(ins.high(v), 0x42);
+    assertEq(v[2], 0x6bbbbbbb);
+
+    ins.set(v);
+    assertEq(v[0], 0x7aaaaaaa);
+    assertEq(v[1], 0x3333333376544567n);
+    assertEq(v[2], 0x6bbbbbbb);
+
+    ins.set2(v);
+    assertEq(v[1], 0x3141592653589793n);
+    assertEq(ins.low(v), 0x53589793);
+    assertEq(ins.high(v), 0x31415926)
+}
+
+{
+    let txt =
+        `(module
+          (type $big (struct
+                      (field (mut i32))
+                      (field (mut i64))
+                      (field (mut i32))))
+
+          (global $g (mut (ref null $big)) (ref.null $big))
+
+          (func (export "make") (result eqref)
+           (global.set $g
+            (struct.new $big (i32.const 0x7aaaaaaa) (i64.const 0x4201020337) (i32.const 0x6bbbbbbb)))
+           (global.get $g))
+
+          (func (export "update0") (param $x i32)
+           (struct.set $big 0 (global.get $g) (local.get $x)))
+
+          (func (export "get0") (result i32)
+           (struct.get $big 0 (global.get $g)))
+
+          (func (export "update1") (param $hi i32) (param $lo i32)
+           (struct.set $big 1 (global.get $g)
+            (i64.or
+             (i64.shl (i64.extend_u/i32 (local.get $hi)) (i64.const 32))
+             (i64.extend_u/i32 (local.get $lo)))))
+
+          (func (export "get1_low") (result i32)
+           (i32.wrap/i64 (struct.get $big 1 (global.get $g))))
+
+          (func (export "get1_high") (result i32)
+           (i32.wrap/i64
+            (i64.shr_u (struct.get $big 1 (global.get $g)) (i64.const 32))))
+
+          (func (export "update2") (param $x i32)
+           (struct.set $big 2 (global.get $g) (local.get $x)))
+
+          (func (export "get2") (result i32)
+           (struct.get $big 2 (global.get $g)))
+
+         )`;
+
+    let ins = wasmEvalText(txt).exports;
+
+    let v = ins.make();
+    assertEq(v[0], 0x7aaaaaaa);
+    assertEq(v[1], 0x4201020337n);
+    assertEq(v[2], 0x6bbbbbbb);
+
+    ins.update0(0x45367101);
+    assertEq(v[0], 0x45367101);
+    assertEq(ins.get0(), 0x45367101);
+    assertEq(v[1], 0x4201020337n);
+    assertEq(v[2], 0x6bbbbbbb);
+
+    ins.update2(0x62345123);
+    assertEq(v[0], 0x45367101);
+    assertEq(v[1], 0x4201020337n);
+    assertEq(ins.get2(), 0x62345123);
+    assertEq(v[2], 0x62345123);
+
+    ins.update1(0x77777777, 0x22222222);
+    assertEq(v[0], 0x45367101);
+    assertEq(ins.get1_low(), 0x22222222);
+    assertEq(ins.get1_high(), 0x77777777);
+    assertEq(v[1], 0x7777777722222222n);
+    assertEq(v[2], 0x62345123);
+}
+
+
+var bin = wasmTextToBinary(
+    `(module
+      (type $cons (struct (field i32) (field (ref null $cons))))
+
+      (global $g (mut (ref null $cons)) (ref.null $cons))
+
+      (func (export "push") (param i32)
+       (global.set $g (struct.new $cons (local.get 0) (global.get $g))))
+
+      (func (export "top") (result i32)
+       (struct.get $cons 0 (global.get $g)))
+
+      (func (export "pop")
+       (global.set $g (struct.get $cons 1 (global.get $g))))
+
+      (func (export "is_empty") (result i32)
+       (ref.is_null (global.get $g)))
+
+      )`);
+
+var mod = new WebAssembly.Module(bin);
+var ins = new WebAssembly.Instance(mod).exports;
+ins.push(37);
+ins.push(42);
+ins.push(86);
+assertEq(ins.top(), 86);
+ins.pop();
+assertEq(ins.top(), 42);
+ins.pop();
+assertEq(ins.top(), 37);
+ins.pop();
+assertEq(ins.is_empty(), 1);
+assertErrorMessage(() => ins.pop(),
+                   WebAssembly.RuntimeError,
+                   /dereferencing null pointer/);
+
+// Check that a wrapped object cannot be passed as an eqref even if the wrapper
+// points to the right type.  This is a temporary restriction, until we're able
+// to avoid dealing with wrappers inside the engine.
+
+{
+    var ins = wasmEvalText(
+        `(module
+          (type $Node (struct (field i32)))
+          (func (export "mk") (result eqref)
+           (struct.new $Node (i32.const 37)))
+          (func (export "f") (param $n eqref) (result eqref)
+           (ref.cast (ref null $Node) (local.get $n))))`).exports;
+    var n = ins.mk();
+    assertEq(ins.f(n), n);
+    assertErrorMessage(() => ins.f(wrapWithProto(n, {})), TypeError, /can only pass a WebAssembly GC object/);
+}
+
+// Field names.
+
+// Test that names map to the right fields.
+
+{
+    let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+        `(module
+          (type $s (struct
+                    (field $x i32)
+                    (field $y i32)))
+
+          (func $f (param $p (ref null $s)) (result i32)
+           (struct.get $s $x (local.get $p)))
+
+          (func $g (param $p (ref null $s)) (result i32)
+           (struct.get $s $y (local.get $p)))
+
+          (func (export "testf") (param $n i32) (result i32)
+           (call $f (struct.new $s (local.get $n) (i32.mul (local.get $n) (i32.const 2)))))
+
+          (func (export "testg") (param $n i32) (result i32)
+           (call $g (struct.new $s (local.get $n) (i32.mul (local.get $n) (i32.const 2)))))
+
+         )`))).exports;
+
+    assertEq(ins.testf(10), 10);
+    assertEq(ins.testg(10), 20);
+}
+
+// Test that field names must be unique in the module.
+
+assertErrorMessage(() => wasmTextToBinary(
+    `(module
+      (type $s (struct (field $x i32)))
+      (type $t (struct (field $x i32)))
+     )`),
+                  SyntaxError,
+                  /duplicate identifier for field/);
+
+// negative tests
+
+// Wrong type passed as initializer
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (type $r (struct (field i32)))
+  (func $f (param f64) (result eqref)
+    (struct.new $r (local.get 0)))
+)`)),
+WebAssembly.CompileError, /type mismatch/);
+
+// Too few values passed for initializer
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (type $r (struct (field i32) (field i32)))
+  (func $f (result eqref)
+    (struct.new $r (i32.const 0)))
+)`)),
+WebAssembly.CompileError, /popping value from empty stack/);
+
+// Too many values passed for initializer, sort of
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (type $r (struct (field i32) (field i32)))
+  (func $f (result eqref)
+    (i32.const 0)
+    (i32.const 1)
+    (i32.const 2)
+    struct.new $r)
+)`)),
+WebAssembly.CompileError, /unused values/);
+
+// Not referencing a structure type
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (type (func (param i32) (result i32)))
+  (func $f (result eqref)
+    (struct.new 0))
+)`)),
+WebAssembly.CompileError, /not a struct type/);
+
+// Nominal type equivalence for structs, but the prefix rule allows this
+// conversion to succeed.
+
+wasmEvalText(`
+ (module
+   (type $p (struct (field i32)))
+   (type $q (struct (field i32)))
+   (func $f (result (ref null $p))
+    (struct.new $q (i32.const 0))))
+`);
+
+// The field name is optional, so this should work.
+
+wasmEvalText(`
+(module
+ (type $s (struct (field i32))))
+`)
+
+// Empty structs are OK.
+
+wasmEvalText(`
+(module
+ (type $s (struct)))
+`)
+
+// Multiply defined structures.
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field $x i32)))
+ (type $s (struct (field $y i32))))
+`),
+SyntaxError, /duplicate type identifier/);
+
+// Bogus type definition syntax.
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s))
+`),
+SyntaxError, /wasm text error/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (field $x i32)))
+`),
+SyntaxError, /expected one of: `func`, `struct`, `array`/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (field $x i31))))
+`),
+SyntaxError, /wasm text error/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct (fjeld $x i32))))
+`),
+SyntaxError, /wasm text error/);
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct abracadabra)))
+`),
+SyntaxError, /wasm text error/);
+
+// Function should not reference struct type: syntactic test
+
+assertErrorMessage(() => wasmEvalText(`
+(module
+ (type $s (struct))
+ (type $f (func (param i32) (result i32)))
+ (func (type 0) (param i32) (result i32) (unreachable)))
+`),
+WebAssembly.CompileError, /signature index references non-signature/);
+
+// Can't set immutable fields from JS
+
+{
+    let ins = wasmEvalText(
+        `(module
+          (type $s (struct
+                    (field i32)
+                    (field (mut i64))))
+          (func (export "make") (result eqref)
+           (struct.new $s (i32.const 37) (i64.const 42))))`).exports;
+    let v = ins.make();
+    assertErrorMessage(() => v[0] = 12,
+                       Error,
+                       /setting immutable field/);
+    assertErrorMessage(() => v[1] = 12,
+                       Error,
+                       /setting immutable field/);
+}
+
+// Function should not reference struct type: binary test
+
+var bad = new Uint8Array([0x00, 0x61, 0x73, 0x6d,
+                          0x01, 0x00, 0x00, 0x00,
+
+                          0x01,                   // Type section
+                          0x03,                   // Section size
+                          0x01,                   // One type
+                          0x5f,                   // Struct
+                          0x00,                   // Zero fields
+
+                          0x03,                   // Function section
+                          0x02,                   // Section size
+                          0x01,                   // One function
+                          0x00,                   // Type of function
+
+                          0x0a,                   // Code section
+                          0x05,                   // Section size
+                          0x01,                   // One body
+                          0x03,                   // Body size
+                          0x00,                   // Zero locals
+                          0x00,                   // UNREACHABLE
+                          0x0b]);                 // END
+
+assertErrorMessage(() => new WebAssembly.Module(bad),
+                   WebAssembly.CompileError, /signature index references non-signature/);
+
+// Exercise alias-analysis code for struct access
+{
+    let txt =
+    `(module
+       (type $meh (struct))
+       (type $hasOOL (struct
+                      ;; In-line storage
+                      (field i64) (field i64)
+                      (field $ILnonref (mut i64)) (field $ILref (mut eqref))
+                      (field i64) (field i64) (field i64) (field i64)
+                      (field i64) (field i64) (field i64) (field i64)
+                      (field i64) (field i64) (field i64) (field i64)
+                      ;; Out-of-line storage (or maybe it starts earlier, but
+                      ;; definitely not after this point).
+                      (field $OOLnonref (mut i64)) (field $OOLref (mut eqref)))
+       )
+       (func (export "create") (result eqref)
+         (struct.new $hasOOL
+           (i64.const 1)    (i64.const 2)
+           (i64.const 9876) (ref.null $meh)
+           (i64.const 3)    (i64.const 4)   (i64.const 5)   (i64.const 6)
+           (i64.const 7)    (i64.const 8)   (i64.const 9)   (i64.const 10)
+           (i64.const 11)   (i64.const 12)  (i64.const 13)  (i64.const 14)
+           (i64.const 4321) (ref.null $meh))
+       )
+       ;; Write to an OOL field, then an IL field, then to an OOL field, so
+       ;; that we can at least check (from inspection of the optimised MIR)
+       ;; that the GVN+alias analysis causes the OOL block pointer not to be
+       ;; reloaded for the second OOL write.  First for non-ref fields ..
+       (func (export "threeSetsNonReffy") (param eqref)
+         (local (ref $hasOOL))
+         (local.set 1 (ref.as_non_null (ref.cast (ref null $hasOOL) (local.get 0))))
+         (struct.set $hasOOL 16 (local.get 1) (i64.const 1337)) ;; set $OOLnonref
+         (struct.set $hasOOL 2  (local.get 1) (i64.const 7331)) ;; set $ILnonref
+         (struct.set $hasOOL 16 (local.get 1) (i64.const 9009)) ;; set $OOLnonref
+       )
+       ;; and the same for ref fields.
+       (func (export "threeSetsReffy") (param eqref)
+         (local (ref $hasOOL))
+         (local.set 1 (ref.as_non_null (ref.cast (ref null $hasOOL) (local.get 0))))
+         (struct.set $hasOOL 17 (local.get 1) (ref.null $meh)) ;; set $OOLref
+         (struct.set $hasOOL 3  (local.get 1) (ref.null $meh)) ;; set $ILref
+         (struct.set $hasOOL 17 (local.get 1) (ref.null $meh)) ;; set $OOLref
+       )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Checks for requests to create structs with more than MaxStructFields, where
+// MaxStructFields == 1000.
+
+function structNewOfManyFields(numFields) {
+    let defString = "(type $s (struct ";
+    for (i = 0; i < numFields; i++) {
+        defString += "(field i32) ";
+    }
+    defString += "))";
+
+    let insnString = "(struct.new $s ";
+    for (i = 0; i < numFields; i++) {
+        insnString += "(i32.const 1337) ";
+    }
+    insnString += ")";
+
+    return "(module " +
+           defString +
+           " (func (export \"create\") (result eqref) " +
+           insnString +
+           "))";
+}
+
+{
+    // 2000 fields is allowable
+    let exports = wasmEvalText(structNewOfManyFields(2000)).exports;
+    let s = exports.create();
+    assertEq(s, s);
+}
+{
+    // but 2001 is not
+    assertErrorMessage(() => wasmEvalText(structNewOfManyFields(2001)),
+                       WebAssembly.CompileError,
+                       /too many fields in struct/);
+}
+
+// FIXME: also check struct.new_default, once it is available in both compilers.
diff --git a/js/src/jit-test/tests/wasm/gc/structs2.js b/js/src/jit-test/tests/wasm/gc/structs2.js
new file mode 100644
index 0000000000..8c5b94db11
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/structs2.js
@@ -0,0 +1,243 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// This tests 8- and 16-bit field accesses for structs.
+
+// Check that struct.new writes for 8-bit fields do not overwrite subsequent
+// data.  Because the writes happen forwards in the address space, the only
+// way I could think to do this is to force an 8-bit field to occupy the last
+// byte of the OOL malloc'd block, and then hope that ASan runs in automation
+// will pick up any overrun.  I think it's impossible to test this from inside
+// the JS+wasm universe.  Hence the test is pretty pointless from a purely
+// JS+wasm interpretation.
+{
+    let txt =
+    `(module
+        (type $hasOOL (struct
+                      ;; In-line storage; 16 fields that preserve 16-alignment
+                      (field i64) (field i64) (field i64) (field i64) ;; 32
+                      (field i64) (field i64) (field i64) (field i64) ;; 64
+                      (field i64) (field i64) (field i64) (field i64) ;; 96
+                      (field i64) (field i64) (field i64) (field i64) ;; 128
+                      ;; Out-of-line storage (or maybe it starts earlier, but
+                      ;; definitely not after this point).  16 bytes on the
+                      ;; basis that StructLayout::close will round the requested
+                      ;; block size up to at max the next 16 byte boundary.
+                      ;; The goal is that the last (field i8) is right at the
+                      ;; end of the resulting malloc'd block, so that, if the
+                      ;; struct.new initialisation code mistakenly initialises
+                      ;; that field with a write larger than 8 bits, then we'll
+                      ;; have a write off the end of the malloc'd block, which
+                      ;; ASan automation runs should detect.
+                      (field i8) (field i8) (field i8) (field i8)
+                      (field i8) (field i8) (field i8) (field i8)
+                      (field i8) (field i8) (field i8) (field i8)
+                      (field i8) (field i8) (field i8) (field i8))
+        )
+        (func (export "build8")
+              (param $filler i64) (param $interesting i32) (result eqref)
+          (struct.new $hasOOL
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+          )
+        )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+    let obj8 = exports.build8(0x1234n, 0x5678);
+    // The above call should trigger OOB writes if the struct.new field
+    // writes are too large, but those will only be visible if we're running
+    // on ASan or Valgrind.  In any case, add a fake data dependency below, so
+    // that the construction of the object can't (so easily) be optimised away.
+    assertEq(obj8[0] + BigInt(obj8[31]), 0x12ACn); // == 0x1234 + 0x78
+}
+
+// And exactly the same, except for 16 bit fields.
+{
+    let txt =
+    `(module
+        (type $hasOOL (struct
+                      ;; in-line storage
+                      (field i64) (field i64) (field i64) (field i64) ;; 32
+                      (field i64) (field i64) (field i64) (field i64) ;; 64
+                      (field i64) (field i64) (field i64) (field i64) ;; 96
+                      (field i64) (field i64) (field i64) (field i64) ;; 128
+                      (field i16) (field i16) (field i16) (field i16)
+                      (field i16) (field i16) (field i16) (field i16))
+        )
+        (func (export "build16")
+              (param $filler i64) (param $interesting i32) (result eqref)
+          (struct.new $hasOOL
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $filler) (local.get $filler)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+                      (local.get $interesting) (local.get $interesting)
+          )
+        )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+    let obj16 = exports.build16(0x4321n, 0x7865);
+    assertEq(obj16[0] + BigInt(obj16[23]), 0xBB86n); // == 0x4321 + 0x7865
+}
+
+// Test that 8-bit field writes do not overwrite adjacent fields.
+{
+    let txt =
+    `(module
+        (type $struct8x8
+           (struct (field i8) (field i8) (field i8) (field (mut i8))
+                   (field i8) (field i8) (field i8) (field i8)
+        ))
+        (func (export "create") (result eqref)
+           (struct.new $struct8x8 (i32.const 0x55) (i32.const 0x55)
+                                  (i32.const 0x55) (i32.const 0x55)
+                                  (i32.const 0x55) (i32.const 0x55)
+                                  (i32.const 0x55) (i32.const 0x55)
+        ))
+        (func (export "writeField8x8_3") (param $p eqref) (param $v i32)
+           (struct.set $struct8x8 3 (ref.cast (ref null $struct8x8) (local.get $p))
+                                    (local.get $v))
+        )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+    let theObject = exports.create();
+    exports.writeField8x8_3(theObject, 0x77);
+    assertEq(theObject[0], 0x55);
+    assertEq(theObject[1], 0x55);
+    assertEq(theObject[2], 0x55);
+    assertEq(theObject[3], 0x77);
+    assertEq(theObject[4], 0x55);
+    assertEq(theObject[5], 0x55);
+    assertEq(theObject[6], 0x55);
+    assertEq(theObject[7], 0x55);
+}
+
+// Test that 16-bit field writes do not overwrite adjacent fields.
+{
+    let txt =
+    `(module
+        (type $struct16x8
+           (struct (field i16) (field i16) (field i16) (field (mut i16))
+                   (field i16) (field i16) (field i16) (field i16)
+        ))
+        (func (export "create") (result eqref)
+           (struct.new $struct16x8 (i32.const 0x5555) (i32.const 0x5555)
+                                   (i32.const 0x5555) (i32.const 0x5555)
+                                   (i32.const 0x5555) (i32.const 0x5555)
+                                   (i32.const 0x5555) (i32.const 0x5555)
+        ))
+        (func (export "writeField16x8_3") (param $p eqref) (param $v i32)
+           (struct.set $struct16x8 3 (ref.cast (ref null $struct16x8) (local.get $p))
+                                    (local.get $v))
+        )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+    let theObject = exports.create();
+    exports.writeField16x8_3(theObject, 0x7766);
+    assertEq(theObject[0], 0x5555);
+    assertEq(theObject[1], 0x5555);
+    assertEq(theObject[2], 0x5555);
+    assertEq(theObject[3], 0x7766);
+    assertEq(theObject[4], 0x5555);
+    assertEq(theObject[5], 0x5555);
+    assertEq(theObject[6], 0x5555);
+    assertEq(theObject[7], 0x5555);
+}
+
+// Test that 8-bit field reads sign/zero extend correctly.
+{
+    let txt =
+    `(module
+        (type $struct8x8
+           (struct (field i8) (field i8) (field i8) (field i8)
+                   (field i8) (field i8) (field i8) (field i8)
+        ))
+        (func (export "create") (result eqref)
+           (struct.new $struct8x8 (i32.const 0x11) (i32.const 0x82)
+                                  (i32.const 0x23) (i32.const 0x94)
+                                  (i32.const 0x35) (i32.const 0xA6)
+                                  (i32.const 0x47) (i32.const 0xB8)
+        ))
+        ;; read i8 from a field, unsigned extend, read value has top bit 0
+        (func (export "readU8hi0") (param $p eqref) (result i32)
+           (struct.get_u $struct8x8 2 (ref.cast (ref null $struct8x8) (local.get $p)))
+        )
+        ;; read i8 from a field, unsigned extend, read value has top bit 1
+        (func (export "readU8hi1") (param $p eqref) (result i32)
+           (struct.get_u $struct8x8 3 (ref.cast (ref null $struct8x8) (local.get $p)))
+        )
+        ;; read i8 from a field, signed extend, read value has top bit 0
+        (func (export "readS8hi0") (param $p eqref) (result i32)
+           (struct.get_s $struct8x8 4 (ref.cast (ref null $struct8x8) (local.get $p)))
+        )
+        ;; read i8 from a field, signed extend, read value has top bit 1
+        (func (export "readS8hi1") (param $p eqref) (result i32)
+           (struct.get_s $struct8x8 5 (ref.cast (ref null $struct8x8) (local.get $p)))
+        )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+    let theObject = exports.create();
+    assertEq(exports.readU8hi0(theObject), 0x23);  // zx of 0x23
+    assertEq(exports.readU8hi1(theObject), 0x94);  // zx of 0x94
+    assertEq(exports.readS8hi0(theObject), 0x35);  // sx of 0x35
+    assertEq(exports.readS8hi1(theObject), -0x5A); // sx of 0xA6
+}
+
+// Test that 16-bit field reads sign/zero extend correctly.
+{
+    let txt =
+    `(module
+        (type $struct16x8
+           (struct (field i16) (field i16) (field i16) (field i16)
+                   (field i16) (field i16) (field i16) (field i16)
+        ))
+        (func (export "create") (result eqref)
+           (struct.new $struct16x8 (i32.const 0x11FF) (i32.const 0x82FE)
+                                   (i32.const 0x23FD) (i32.const 0x94FC)
+                                   (i32.const 0x35FB) (i32.const 0xA6FA)
+                                   (i32.const 0x47F9) (i32.const 0xB8F8)
+        ))
+        ;; read i16 from a field, unsigned extend, read value has top bit 0
+        (func (export "readU16hi0") (param $p eqref) (result i32)
+           (struct.get_u $struct16x8 2 (ref.cast (ref null $struct16x8) (local.get $p)))
+        )
+        ;; read i16 from a field, unsigned extend, read value has top bit 1
+        (func (export "readU16hi1") (param $p eqref) (result i32)
+           (struct.get_u $struct16x8 3 (ref.cast (ref null $struct16x8) (local.get $p)))
+        )
+        ;; read i16 from a field, signed extend, read value has top bit 0
+        (func (export "readS16hi0") (param $p eqref) (result i32)
+           (struct.get_s $struct16x8 4 (ref.cast (ref null $struct16x8) (local.get $p)))
+        )
+        ;; read i16 from a field, signed extend, read value has top bit 1
+        (func (export "readS16hi1") (param $p eqref) (result i32)
+           (struct.get_s $struct16x8 5 (ref.cast (ref null $struct16x8) (local.get $p)))
+        )
+     )`;
+    let exports = wasmEvalText(txt).exports;
+    let theObject = exports.create();
+    assertEq(exports.readU16hi0(theObject), 0x23FD);  // zx of 0x23FD
+    assertEq(exports.readU16hi1(theObject), 0x94FC);  // zx of 0x94FC
+    assertEq(exports.readS16hi0(theObject), 0x35FB);  // sx of 0x35FB
+    assertEq(exports.readS16hi1(theObject), -0x5906); // sx of 0xA6FC
+}
diff --git a/js/src/jit-test/tests/wasm/gc/supertype_later_in_group.js b/js/src/jit-test/tests/wasm/gc/supertype_later_in_group.js
new file mode 100644
index 0000000000..6f5ce48282
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/supertype_later_in_group.js
@@ -0,0 +1,15 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// Checking that we are correctly validating all subtyping rules.
+// In this example, $b should be a subtype of $a, even if their field types
+// will be loaded later.
+wasmValidateText(`
+(module
+    (rec
+        (type $a (struct (field (ref $notParsedYet))))
+        (type $b (sub $a (struct (field (ref $notParsedYet2)))))
+
+        (type $notParsedYet (struct))
+        (type $notParsedYet2 (sub $notParsedYet (struct (field i32))))
+    )
+)`);
diff --git a/js/src/jit-test/tests/wasm/gc/tables-generalized-struct.js b/js/src/jit-test/tests/wasm/gc/tables-generalized-struct.js
new file mode 100644
index 0000000000..b0bd964027
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/tables-generalized-struct.js
@@ -0,0 +1,48 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+// table.set in bounds with i32 x eqref - works, no value generated
+// table.set with (ref null T) - works
+// table.set with null - works
+// table.set out of bounds - fails
+
+{
+    let ins = wasmEvalText(
+        `(module
+           (table (export "t") 10 eqref)
+           (type $dummy (struct (field i32)))
+           (func (export "set_eqref") (param i32) (param eqref)
+             (table.set (local.get 0) (local.get 1)))
+           (func (export "set_null") (param i32)
+             (table.set (local.get 0) (ref.null eq)))
+           (func (export "set_ref") (param i32) (param eqref)
+             (table.set (local.get 0) (ref.cast (ref null $dummy) (local.get 1))))
+           (func (export "make_struct") (result eqref)
+             (struct.new $dummy (i32.const 37))))`);
+    let a = ins.exports.make_struct();
+    ins.exports.set_eqref(3, a);
+    assertEq(ins.exports.t.get(3), a);
+    ins.exports.set_null(3);
+    assertEq(ins.exports.t.get(3), null);
+    let b = ins.exports.make_struct();
+    ins.exports.set_ref(5, b);
+    assertEq(ins.exports.t.get(5), b);
+
+    assertErrorMessage(() => ins.exports.set_eqref(10, a), WebAssembly.RuntimeError, /index out of bounds/);
+    assertErrorMessage(() => ins.exports.set_eqref(-1, a), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// table.grow on table of eqref with non-null ref value
+
+{
+    let ins = wasmEvalText(
+        `(module
+          (type $S (struct (field i32) (field f64)))
+          (table (export "t") 2 eqref)
+          (func (export "f") (result i32)
+           (table.grow (struct.new $S (i32.const 0) (f64.const 3.14)) (i32.const 1))))`);
+    assertEq(ins.exports.t.length, 2);
+    assertEq(ins.exports.f(), 2);
+    assertEq(ins.exports.t.length, 3);
+    assertEq(typeof ins.exports.t.get(2), "object");
+}
+
diff --git a/js/src/jit-test/tests/wasm/gc/trailers-gc-stress.js b/js/src/jit-test/tests/wasm/gc/trailers-gc-stress.js
new file mode 100644
index 0000000000..d1975a9541
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/trailers-gc-stress.js
@@ -0,0 +1,166 @@
+// |jit-test| skip-if: !wasmGcEnabled() || getBuildConfiguration().simulator
+
+// This test is intended to test what was committed in
+//
+//  Bug 1817385 - wasm-gc: reduce cost of allocation and GC paths
+//  and
+//  Bug 1820120 - Manage Wasm{Array,Struct}Object OOL-storage-blocks
+//                using a thread-private cache
+//
+// and in particular the latter.  The patches in these bugs reduce the cost of
+// wasm-gc struct/array allocation and collection, in part by better
+// integrating those objects with our generational GC facility.
+//
+// Existing tests do not cover all of those paths.  In particular they do not
+// exercise both set-subtraction algorithms in Nursery::freeTrailerBlocks.
+// This test does, though.
+//
+// The test first creates an "primary" array of 1500 elements.  Each element
+// is a reference to a secondary array of between 1 and 50 int32s.  These
+// secondary arrays have size chosen randomly, and the elements are also
+// random.
+//
+// Then, elements of the primary array are replaced.  An index in the range 0
+// .. N - 1 is randomly chosen, and the element there is replaced by a
+// randomly-created secondary array.  This is repeated 500,000 times with
+// N = 800.
+//
+// Finally, all of the above is repeated, but with N = 1200.
+//
+// As a result just over a million arrays and their trailer blocks, of various
+// sizes, are allocated and deallocated.  With N = 800, in
+// js::Nursery::freeTrailerBlocks, we end up with trailersRemovedUsed_ of
+// around 800, so one of the set-subtraction algorithms is exercised.
+// With N = 1200, the other is exercised.  It's not entirely clear why changing
+// N causes trailersRemovedUsed_ to have more or less the same value during
+// nursery collection, but the correlation does seem fairly robust.
+//
+// The test is skipped on the simulator because it takes too long to run, and
+// triggers timeouts.
+
+let t =
+`(module
+
+   ;; A simple pseudo-random number generator.
+   ;; Produces numbers in the range 0 .. 2^16-1.
+   (global $rngState
+     (mut i32) (i32.const 1)
+   )
+   (func $rand (export "rand") (result i32)
+     (local $t i32)
+     ;; update $rngState
+     (local.set $t (global.get $rngState))
+     (local.set $t (i32.mul (local.get $t) (i32.const 1103515245)))
+     (local.set $t (i32.add (local.get $t) (i32.const 12345)))
+     (global.set $rngState (local.get $t))
+     ;; pull 16 random bits out of it
+     (local.set $t (i32.shr_u (local.get $t) (i32.const 15)))
+     (local.set $t (i32.and (local.get $t) (i32.const 0xFFFF)))
+     (local.get $t)
+   )
+
+   ;; Array types
+   (type $tArrayI32      (array (mut i32)))  ;; "secondary array" above
+   (type $tArrayArrayI32 (array (mut (ref null $tArrayI32)))) ;; "primary array"
+
+   ;; Create an array ("secondary array") containing random numbers, with a
+   ;; size between 1 and 50, also randomly chosen.
+   (func $createSecondaryArray (export "createSecondaryArray")
+                               (result (ref $tArrayI32))
+     (local $i i32)
+     (local $nElems i32)
+     (local $arr (ref $tArrayI32))
+     (local.set $nElems (call $rand))
+     (local.set $nElems (i32.rem_u (local.get $nElems) (i32.const 50)))
+     (local.set $nElems (i32.add   (local.get $nElems) (i32.const 1)))
+     (local.set $arr (array.new $tArrayI32 (i32.const 0) (local.get $nElems)))
+     (loop $cont
+       (array.set $tArrayI32 (local.get $arr) (local.get $i) (call $rand))
+       (local.set $i (i32.add (local.get $i) (i32.const 1)))
+       (br_if $cont (i32.lt_u (local.get $i) (local.get $nElems)))
+     )
+     (local.get $arr)
+   )
+
+   ;; Create an array (the "primary array") of 1500 elements of
+   ;; type ref-of-tArrayI32.
+   (func $createPrimaryArray (export "createPrimaryArray")
+                             (result (ref $tArrayArrayI32))
+     (local $i i32)
+     (local $arrarr (ref $tArrayArrayI32))
+     (local.set $arrarr (array.new $tArrayArrayI32 (ref.null $tArrayI32)
+                                                   (i32.const 1500)))
+     (loop $cont
+       (array.set $tArrayArrayI32 (local.get $arrarr)
+                                  (local.get $i) (call $createSecondaryArray))
+       (local.set $i (i32.add (local.get $i) (i32.const 1)))
+       (br_if $cont (i32.lt_u (local.get $i) (i32.const 1500)))
+     )
+     (local.get $arrarr)
+   )
+
+   ;; Use $createPrimaryArray to create an initial array.  Then randomly replace
+   ;; elements for a while.
+   (func $churn (export "churn") (param $thresh i32) (result i32)
+     (local $i i32)
+     (local $j i32)
+     (local $finalSum i32)
+     (local $arrarr (ref $tArrayArrayI32))
+     (local $arr (ref null $tArrayI32))
+     (local $arrLen i32)
+     (local.set $arrarr (call $createPrimaryArray))
+     ;; This loop iterates 500,000 times.  Each iteration, it chooses
+     ;; a randomly element in $arrarr and replaces it with a new
+     ;; random array of 32-bit ints.
+     (loop $cont
+       ;; make $j be a random number in 0 .. $thresh-1.
+       ;; Then replace that index in $arrarr with a new random arrayI32.
+       (local.set $j (i32.rem_u (call $rand) (local.get $thresh)))
+       (array.set $tArrayArrayI32 (local.get $arrarr)
+                                  (local.get $j) (call $createSecondaryArray))
+       (local.set $i (i32.add (local.get $i) (i32.const 1)))
+       (br_if $cont (i32.lt_u (local.get $i) (i32.const 500000)))
+     )
+
+     ;; Finally, compute a checksum by summing all the numbers
+     ;; in all secondary arrays.  This simply assumes that all of the refs to
+     ;; secondary arrays are non-null, which isn't per-se guaranteed by the
+     ;; previous loop, but it works in this case because the RNG
+     ;; produces each index value to overwrite at least once.
+     (local.set $finalSum (i32.const 0))
+     (local.set $i (i32.const 0)) ;; loop var for the outer loop
+     (loop $outer
+       ;; body of outer loop
+       ;; $arr = $arrarr[i]
+       (local.set $arr (array.get $tArrayArrayI32 (local.get $arrarr)
+                       (local.get $i)))
+       ;; iterate over $arr
+       (local.set $arrLen (array.len (local.get $arr)))
+       (local.set $j (i32.const 0)) ;; loop var for the inner loop
+       (loop $inner
+         ;; body of inner loop
+         (local.set $finalSum
+                    (i32.rotl (local.get $finalSum) (i32.const 1)))
+         (local.set $finalSum
+                    (i32.xor (local.get $finalSum)
+                             (array.get $tArrayI32 (local.get $arr)
+                                                   (local.get $j))))
+         ;; loop control for the inner loop
+         (local.set $j (i32.add (local.get $j) (i32.const 1)))
+         (br_if $inner (i32.lt_u (local.get $j) (local.get $arrLen)))
+       )
+       ;; loop control for the outer loop
+       (local.set $i (i32.add (local.get $i) (i32.const 1)))
+       (br_if $outer (i32.lt_u (local.get $i) (i32.const 1500)))
+     )
+
+     ;; finally, roll in the final value of the RNG state
+     (i32.xor (local.get $finalSum) (global.get $rngState))
+   )
+)`;
+
+let i = wasmEvalText(t);
+let fns = i.exports;
+
+assertEq(fns.churn(800), -575895114);
+assertEq(fns.churn(1200), -1164697516);
diff --git a/js/src/jit-test/tests/wasm/gc/value_subtyping.js b/js/src/jit-test/tests/wasm/gc/value_subtyping.js
new file mode 100644
index 0000000000..bc0a3df678
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/gc/value_subtyping.js
@@ -0,0 +1,305 @@
+// |jit-test| skip-if: !wasmGcEnabled()
+
+function simpleTypeSection(types) {
+  return types.map((x, i) => `(type \$${i} ${x})`).join('\n');
+}
+
+function assertSubtype(superType, subType, types) {
+  types = types || [];
+  wasmEvalText(`(module
+    ${types}
+    (func
+      unreachable
+      (block (param ${subType})
+        (block (param ${superType})
+          drop
+        )
+      )
+    )
+  )`);
+}
+
+function assertNotSubtype(superType, subType, types) {
+  assertErrorMessage(() => {
+    assertSubtype(superType, subType, types);
+  }, WebAssembly.CompileError, /type mismatch/);
+}
+
+// Primitive trivial subtyping
+assertSubtype('i32', 'i32');
+assertSubtype('i64', 'i64');
+assertSubtype('f32', 'f32');
+assertSubtype('f64', 'f64');
+assertSubtype('eqref', 'eqref');
+assertSubtype('funcref', 'funcref');
+
+// No subtyping relation between funcref, anyref, externref. These are our top
+// types.
+assertNotSubtype('funcref', 'anyref');
+assertNotSubtype('anyref', 'funcref');
+assertNotSubtype('funcref', 'externref');
+assertNotSubtype('externref', 'funcref');
+assertNotSubtype('externref', 'anyref');
+assertNotSubtype('anyref', 'externref');
+
+// eqref is a subtype of anyref
+assertSubtype('anyref', 'eqref');
+
+// structref is a subtype of eqref and anyref
+assertSubtype('anyref', 'structref');
+assertSubtype('eqref', 'structref');
+
+// arrayref is a subtype of eqref and anyref
+assertSubtype('anyref', 'arrayref');
+assertSubtype('eqref', 'arrayref');
+
+// Structs are subtypes of anyref, eqref, and structref
+assertSubtype(
+ 'anyref',
+ '(ref 0)',
+ simpleTypeSection(['(struct)']));
+assertSubtype(
+ 'eqref',
+ '(ref 0)',
+ simpleTypeSection(['(struct)']));
+assertSubtype(
+ 'structref',
+ '(ref 0)',
+ simpleTypeSection(['(struct)']));
+
+// Struct identity
+assertSubtype(
+ '(ref 0)',
+ '(ref 1)',
+ simpleTypeSection(['(struct)', '(struct)']));
+assertSubtype(
+ '(ref 1)',
+ '(ref 0)',
+ simpleTypeSection(['(struct)', '(struct)']));
+
+// Self referential struct
+assertSubtype(
+ '(ref 1)',
+ '(ref 0)',
+ simpleTypeSection(['(struct (ref 0))', '(struct (ref 1))']));
+
+// Mutually referential structs
+assertSubtype(
+ '(ref 2)',
+ '(ref 0)',
+ `(rec
+    (type (struct (ref 1)))
+    (type (struct (ref 0)))
+  )
+  (rec
+    (type (struct (ref 3)))
+    (type (struct (ref 2)))
+  )`);
+
+// Struct subtypes can have extra fields
+assertSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  `(type (struct))
+   (type (sub 0 (struct (field i32))))`);
+assertSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  `(type (struct))
+   (type (sub 0 (struct (field i32) (field i32))))`);
+
+// Struct supertypes cannot have extra fields
+assertNotSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(struct (field i32))',
+    '(struct)']));
+
+// Struct field mutability must match
+assertSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(struct (field (mut i32)))',
+    '(struct (field (mut i32)))']));
+assertSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(struct (field i32))',
+    '(struct (field i32))']));
+assertNotSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(struct (field (mut i32)))',
+    '(struct (field i32))']));
+assertNotSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(struct (field i32))',
+    '(struct (field (mut i32)))']));
+
+// Struct fields are invariant when mutable
+assertSubtype(
+  '(ref 2)',
+  '(ref 3)',
+  simpleTypeSection([
+    '(struct)',
+    '(struct)',
+    '(struct (field (mut (ref 0))))',
+    '(struct (field (mut (ref 1))))']));
+assertNotSubtype(
+  '(ref 2)',
+  '(ref 3)',
+  simpleTypeSection([
+    '(struct)',
+    '(struct (field i32))',
+    '(struct (field (mut (ref 0))))',
+    '(struct (field (mut (ref 1))))']));
+
+// Struct fields are covariant when immutable
+assertSubtype(
+  '(ref 2)',
+  '(ref 3)',
+  `(type (struct))
+   (type (sub 0 (struct (field i32))))
+   (type (struct (field (ref 0))))
+   (type (sub 2 (struct (field (ref 1)))))`);
+
+// Arrays are subtypes of anyref, eqref, and arrayref
+assertSubtype(
+ 'anyref',
+ '(ref 0)',
+ simpleTypeSection(['(array i32)']));
+assertSubtype(
+ 'eqref',
+ '(ref 0)',
+ simpleTypeSection(['(array i32)']));
+assertSubtype(
+ 'arrayref',
+ '(ref 0)',
+ simpleTypeSection(['(array i32)']));
+
+// Array identity
+assertSubtype(
+ '(ref 0)',
+ '(ref 1)',
+ simpleTypeSection(['(array i32)', '(array i32)']));
+assertSubtype(
+ '(ref 1)',
+ '(ref 0)',
+ simpleTypeSection(['(array i32)', '(array i32)']));
+
+// Self referential array
+assertSubtype(
+ '(ref 1)',
+ '(ref 0)',
+ simpleTypeSection(['(array (ref 0))', '(array (ref 1))']));
+
+// Mutually referential arrays
+assertSubtype(
+ '(ref 2)',
+ '(ref 0)',
+ `(rec
+   (type (array (ref 1)))
+   (type (array (ref 0)))
+  )
+  (rec
+   (type (array (ref 3)))
+   (type (array (ref 2)))
+  )`);
+
+// Array mutability must match
+assertSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(array (mut i32))',
+    '(array (mut i32))']));
+assertSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(array i32)',
+    '(array i32)']));
+assertNotSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(array (mut i32))',
+    '(array i32)']));
+assertNotSubtype(
+  '(ref 0)',
+  '(ref 1)',
+  simpleTypeSection([
+    '(array i32)',
+    '(array (mut i32))']));
+
+// Array elements are invariant when mutable
+assertSubtype(
+  '(ref 2)',
+  '(ref 3)',
+  simpleTypeSection([
+   '(struct)',
+   '(struct)',
+   '(array (mut (ref 0)))',
+   '(array (mut (ref 1)))']));
+assertNotSubtype(
+  '(ref 2)',
+  '(ref 3)',
+  simpleTypeSection([
+   '(struct)',
+   '(struct (field i32))',
+   '(array (mut (ref 0)))',
+   '(array (mut (ref 1)))']));
+
+// Array elements are covariant when immutable
+assertSubtype(
+  '(ref 2)',
+  '(ref 3)',
+  `(type (struct))
+   (type (sub 0 (struct (field i32))))
+   (type (array (ref 0)))
+   (type (sub 2 (array (ref 1))))`);
+
+// nullref is a subtype of everything in anyref hierarchy
+assertSubtype('anyref', 'nullref');
+assertSubtype('eqref', 'nullref');
+assertSubtype('structref', 'nullref');
+assertSubtype('arrayref', 'nullref');
+assertSubtype('(ref null 0)', 'nullref', simpleTypeSection(['(struct)']));
+assertSubtype('(ref null 0)', 'nullref', simpleTypeSection(['(array i32)']));
+
+// nullref is not a subtype of any other hierarchy
+assertNotSubtype('funcref', 'nullref');
+assertNotSubtype('(ref null 0)', 'nullref', simpleTypeSection(['(func)']));
+assertNotSubtype('externref', 'nullref');
+
+// nullfuncref is a subtype of everything in funcref hierarchy
+assertSubtype('funcref', 'nullfuncref');
+assertSubtype('(ref null 0)', 'nullfuncref', simpleTypeSection(['(func)']));
+
+// nullfuncref is not a subtype of any other hierarchy
+assertNotSubtype('anyref', 'nullfuncref');
+assertNotSubtype('eqref', 'nullfuncref');
+assertNotSubtype('structref', 'nullfuncref');
+assertNotSubtype('arrayref', 'nullfuncref');
+assertNotSubtype('externref', 'nullfuncref');
+assertNotSubtype('(ref null 0)', 'nullfuncref', simpleTypeSection(['(struct)']));
+assertNotSubtype('(ref null 0)', 'nullfuncref', simpleTypeSection(['(array i32)']));
+
+// nullexternref is a subtype of everything in externref hierarchy
+assertSubtype('externref', 'nullexternref');
+
+// nullexternref is not a subtype of any other hierarchy
+assertNotSubtype('anyref', 'nullexternref');
+assertNotSubtype('eqref', 'nullexternref');
+assertNotSubtype('structref', 'nullexternref');
+assertNotSubtype('arrayref', 'nullexternref');
+assertNotSubtype('funcref', 'nullexternref');
+assertNotSubtype('(ref null 0)', 'nullexternref', simpleTypeSection(['(struct)']));
+assertNotSubtype('(ref null 0)', 'nullexternref', simpleTypeSection(['(array i32)']));
+assertNotSubtype('(ref null 0)', 'nullexternref', simpleTypeSection(['(func)']));
diff --git a/js/src/jit-test/tests/wasm/globals-impl.js b/js/src/jit-test/tests/wasm/globals-impl.js
new file mode 100644
index 0000000000..f5ff8a3f5d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/globals-impl.js
@@ -0,0 +1,49 @@
+// This is intended to test that Ion correctly handles the combination
+// {direct, indirect} x {i32, i64} for global variables, following GVN
+// improvements pertaining to globals in bug 1448277.
+
+let txt =
+  `(module
+     ;; -------- Globals --------
+     (global $ind64 (export "ind64") (mut i64) (i64.const 4242))
+     (global $ind32 (export "ind32") (mut i32) (i32.const 3141))
+     (global $dir64 (mut i64) (i64.const 5927))
+     (global $dir32 (mut i32) (i32.const 2718))
+     ;; -------- FUNCTION 0 --------
+     (func (export "function0") (result i32)
+       (local $loopctr i32)
+       (local $sum     i32)
+       (local $tmp64   i64)
+       (local $tmp32   i32)
+       (loop
+          (global.set $ind64 (i64.add (global.get $ind64) (i64.const 11)))
+          (global.set $ind32 (i32.add (global.get $ind32) (i32.const 22)))
+          (global.set $dir64 (i64.add (global.get $dir64) (i64.const 33)))
+          (global.set $dir32 (i32.add (global.get $dir32) (i32.const 44)))
+
+          (local.set $tmp64 (i64.and (global.get $ind64) (global.get $dir64)))
+          (local.set $tmp32 (i32.or  (global.get $ind32) (global.get $dir32)))
+
+          (local.set $sum
+            (i32.sub (local.get $sum) (i32.xor (i32.wrap/i64 (local.get $tmp64))
+                                               (local.get $tmp32))))
+
+          (local.set $loopctr
+            (i32.add (local.get $loopctr) (i32.const 1)))
+          (br_if 0
+            (i32.lt_u (local.get $loopctr) (i32.const 10)))
+
+       )
+       (local.get $sum)
+     )
+   )`;
+
+function test_driver()
+{
+    let bin  = wasmTextToBinary(txt);
+    let inst = new WebAssembly.Instance(new WebAssembly.Module(bin));
+    let res  = inst.exports.function0();
+    assertEq(res, -79170);
+}
+
+test_driver();
diff --git a/js/src/jit-test/tests/wasm/globals.js b/js/src/jit-test/tests/wasm/globals.js
new file mode 100644
index 0000000000..186ceb6350
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/globals.js
@@ -0,0 +1,556 @@
+// |jit-test| test-also=--wasm-extended-const; test-also=--no-wasm-extended-const
+
+const { Instance, Module, LinkError } = WebAssembly;
+
+// Locally-defined globals
+assertErrorMessage(() => wasmEvalText(`(module (global))`), SyntaxError, /wasm text error/);
+// A global field in the text format is valid with an empty expression, but this produces an invalid module
+assertErrorMessage(() => wasmEvalText(`(module (global i32))`), WebAssembly.CompileError, /popping value/);
+assertErrorMessage(() => wasmEvalText(`(module (global (mut i32)))`), WebAssembly.CompileError, /popping value/);
+
+// Initializer expressions.
+wasmFailValidateText(`(module (global i32 (f32.const 13.37)))`, /type mismatch/);
+wasmFailValidateText(`(module (global f64 (f32.const 13.37)))`, /type mismatch/);
+
+wasmFailValidateText(`(module (global i32 (global.get 0)))`, /out of range/);
+wasmFailValidateText(`(module (global i32 (global.get 1)) (global i32 (i32.const 1)))`, /out of range/);
+
+// Test a well-defined global section.
+function testInner(type, initialValue, nextValue, coercion)
+{
+    var module = wasmEvalText(`(module
+        (global (mut ${type}) (${type}.const ${initialValue}))
+        (global ${type} (${type}.const ${initialValue}))
+
+        (func $get (result ${type}) (global.get 0))
+        (func $set (param ${type}) (global.set 0 (local.get 0)))
+
+        (func $get_cst (result ${type}) (global.get 1))
+
+        (export "get" (func $get))
+        (export "get_cst" (func $get_cst))
+
+        (export "set" (func $set))
+    )`).exports;
+
+    assertEq(module.get(), coercion(initialValue));
+    assertEq(module.set(coercion(nextValue)), undefined);
+    assertEq(module.get(), coercion(nextValue));
+
+    assertEq(module.get_cst(), coercion(initialValue));
+}
+
+testInner('i32', 13, 37, x => x|0);
+testInner('f32', 13.37, 0.1989, Math.fround);
+testInner('f64', 13.37, 0.1989, x => +x);
+
+// Extended const stuff
+if (wasmExtendedConstEnabled()) {
+    // Basic global shenanigans
+    {
+        const module = wasmEvalText(`(module
+            ;; -2 * (5 - (-10 + 20)) = 10
+            (global i32 (i32.mul (i32.const -2) (i32.sub (i32.const 5) (i32.add (i32.const -10) (i32.const 20)))))
+            ;; ((1 + 2) - (3 * 4)) = -9
+            (global i64 (i64.sub (i64.add (i64.const 1) (i64.const 2)) (i64.mul (i64.const 3) (i64.const 4))))
+
+            (func (export "get0") (result i32) global.get 0)
+            (func (export "get1") (result i64) global.get 1)
+        )`).exports;
+
+        assertEq(module.get0(), 10);
+        assertEq(module.get1(), -9n);
+    }
+
+    // Example use of dynamic linking
+    {
+        // Make a memory for two dynamically-linked modules to share. Each module gets five pages.
+        const mem = new WebAssembly.Memory({ initial: 15, maximum: 15 });
+
+        const mod1 = new WebAssembly.Module(wasmTextToBinary(`(module
+            (memory (import "env" "memory") 15 15)
+            (global $memBase (import "env" "__memory_base") i32)
+            (data (offset (global.get $memBase)) "Hello from module 1.")
+            (data (offset (i32.add (global.get $memBase) (i32.const 65536))) "Goodbye from module 1.")
+        )`));
+        const instance1 = new WebAssembly.Instance(mod1, {
+            env: {
+                memory: mem,
+                __memory_base: 65536 * 5, // this module's memory starts at page 5
+            },
+        });
+
+        const mod2 = new WebAssembly.Module(wasmTextToBinary(`(module
+            (memory (import "env" "memory") 15 15)
+            (global $memBase (import "env" "__memory_base") i32)
+            (data (offset (global.get $memBase)) "Hello from module 2.")
+            (data (offset (i32.add (global.get $memBase) (i32.const 65536))) "Goodbye from module 2.")
+        )`));
+        const instance2 = new WebAssembly.Instance(mod2, {
+            env: {
+                memory: mem,
+                __memory_base: 65536 * 10, // this module's memory starts at page 10
+            },
+        });
+
+        // All four strings should now be present in the memory.
+
+        function assertStringInMem(mem, str, addr) {
+            const bytes = new Uint8Array(mem.buffer).slice(addr, addr + str.length);
+            let memStr = String.fromCharCode(...bytes);
+            assertEq(memStr, str);
+        }
+
+        assertStringInMem(mem, "Hello from module 1.", 65536 * 5);
+        assertStringInMem(mem, "Goodbye from module 1.", 65536 * 6);
+        assertStringInMem(mem, "Hello from module 2.", 65536 * 10);
+        assertStringInMem(mem, "Goodbye from module 2.", 65536 * 11);
+    }
+}
+
+// Semantic errors.
+wasmFailValidateText(`(module (global (mut i32) (i32.const 1337)) (func (global.set 1 (i32.const 0))))`, /(out of range)|(global index out of bounds)/);
+wasmFailValidateText(`(module (global i32 (i32.const 1337)) (func (global.set 0 (i32.const 0))))`, /(can't write an immutable global)|(global is immutable)/);
+
+// Big module with many variables: test that setting one doesn't overwrite the
+// other ones.
+function get_set(i, type) {
+    return `
+        (func $get_${i} (result ${type}) (global.get ${i}))
+        (func $set_${i} (param ${type}) (global.set ${i} (local.get 0)))
+    `;
+}
+
+var module = wasmEvalText(`(module
+    (global (mut i32) (i32.const 42))
+    (global (mut i32) (i32.const 10))
+    (global (mut f32) (f32.const 13.37))
+    (global (mut f64) (f64.const 13.37))
+    (global (mut i32) (i32.const -18))
+
+    ${get_set(0, 'i32')}
+    ${get_set(1, 'i32')}
+    ${get_set(2, 'f32')}
+    ${get_set(3, 'f64')}
+    ${get_set(4, 'i32')}
+
+    (export "get0" (func $get_0)) (export "set0" (func $set_0))
+    (export "get1" (func $get_1)) (export "set1" (func $set_1))
+    (export "get2" (func $get_2)) (export "set2" (func $set_2))
+    (export "get3" (func $get_3)) (export "set3" (func $set_3))
+    (export "get4" (func $get_4)) (export "set4" (func $set_4))
+)`).exports;
+
+let values = [42, 10, Math.fround(13.37), 13.37, -18];
+let nextValues = [13, 37, Math.fround(-17.89), 9.3, -13];
+for (let i = 0; i < 5; i++) {
+    assertEq(module[`get${i}`](), values[i]);
+    assertEq(module[`set${i}`](nextValues[i]), undefined);
+    assertEq(module[`get${i}`](), nextValues[i]);
+    for (let j = 0; j < 5; j++) {
+        if (i === j)
+            continue;
+        assertEq(module[`get${j}`](), values[j]);
+    }
+    assertEq(module[`set${i}`](values[i]), undefined);
+    assertEq(module[`get${i}`](), values[i]);
+}
+
+// Initializer expressions can also be used in elem section initializers.
+wasmFailValidateText(`(module (import "globals" "a" (global f32)) (table 4 funcref) (elem (global.get 0) $f) (func $f))`, /type mismatch/);
+
+module = wasmEvalText(`(module
+    (import "globals" "a" (global i32))
+    (table (export "tbl") 4 funcref)
+    (elem (global.get 0) $f)
+    (func $f)
+    (export "f" (func $f))
+)`, {
+    globals: {
+        a: 1
+    }
+}).exports;
+assertEq(module.f, module.tbl.get(1));
+
+// Import/export semantics.
+module = wasmEvalText(`(module
+ (import "globals" "x" (global $g i32))
+ (func $get (result i32) (global.get $g))
+ (export "getter" (func $get))
+ (export "value" (global 0))
+)`, { globals: {x: 42} }).exports;
+
+assertEq(module.getter(), 42);
+
+// assertEq() will not trigger @@toPrimitive, so we must have a cast here.
+assertEq(Number(module.value), 42);
+
+// Can only import numbers (no implicit coercions).
+module = new Module(wasmTextToBinary(`(module
+    (global (import "globs" "i32") i32)
+    (global (import "globs" "f32") f32)
+    (global (import "globs" "f64") f32)
+)`));
+
+const assertLinkFails = (m, imp, err) => {
+    assertErrorMessage(() => new Instance(m, imp), LinkError, err);
+}
+
+var imp = {
+    globs: {
+        i32: 0,
+        f32: Infinity,
+        f64: NaN
+    }
+};
+
+let i = new Instance(module, imp);
+
+for (let v of [
+    null,
+    {},
+    "42",
+    /not a number/,
+    false,
+    undefined,
+    Symbol(),
+    { valueOf() { return 42; } }
+]) {
+    imp.globs.i32 = v;
+    assertLinkFails(module, imp, /not a Number/);
+
+    imp.globs.i32 = 0;
+    imp.globs.f32 = v;
+    assertLinkFails(module, imp, /not a Number/);
+
+    imp.globs.f32 = Math.fround(13.37);
+    imp.globs.f64 = v;
+    assertLinkFails(module, imp, /not a Number/);
+
+    imp.globs.f64 = 13.37;
+}
+
+// Imported globals and locally defined globals use the same index space.
+module = wasmEvalText(`(module
+ (import "globals" "x" (global i32))
+ (global i32 (i32.const 1337))
+ (export "imported" (global 0))
+ (export "defined" (global 1))
+)`, { globals: {x: 42} }).exports;
+
+assertEq(Number(module.imported), 42);
+assertEq(Number(module.defined), 1337);
+
+// Initializer expressions can reference an imported immutable global.
+wasmFailValidateText(`(module (global f32 (f32.const 13.37)) (global i32 (global.get 0)))`, /must reference a global immutable import/);
+wasmFailValidateText(`(module (global (mut f32) (f32.const 13.37)) (global i32 (global.get 0)))`, /must reference a global immutable import/);
+wasmFailValidateText(`(module (global (mut i32) (i32.const 0)) (global i32 (global.get 0)))`, /must reference a global immutable import/);
+
+wasmFailValidateText(`(module (import "globals" "a" (global f32)) (global i32 (global.get 0)))`, /type mismatch/);
+
+function testInitExpr(type, initialValue, nextValue, coercion, assertFunc = assertEq) {
+    var module = wasmEvalText(`(module
+        (import "globals" "a" (global ${type}))
+
+        (global $glob_mut (mut ${type}) (global.get 0))
+        (global $glob_imm ${type} (global.get 0))
+
+        (func $get0 (result ${type}) (global.get 0))
+
+        (func $get1 (result ${type}) (global.get 1))
+        (func $set1 (param ${type}) (global.set 1 (local.get 0)))
+
+        (func $get_cst (result ${type}) (global.get 2))
+
+        (export "get0" (func $get0))
+        (export "get1" (func $get1))
+        (export "get_cst" (func $get_cst))
+
+        (export "set1" (func $set1))
+        (export "global_imm" (global $glob_imm))
+    )`, {
+        globals: {
+            a: coercion(initialValue)
+        }
+    }).exports;
+
+    assertFunc(module.get0(), coercion(initialValue));
+    assertFunc(module.get1(), coercion(initialValue));
+    assertFunc(Number(module.global_imm), coercion(initialValue));
+
+    assertEq(module.set1(coercion(nextValue)), undefined);
+    assertFunc(module.get1(), coercion(nextValue));
+    assertFunc(module.get0(), coercion(initialValue));
+    assertFunc(Number(module.global_imm), coercion(initialValue));
+
+    assertFunc(module.get_cst(), coercion(initialValue));
+}
+
+testInitExpr('i32', 13, 37, x => x|0);
+testInitExpr('f32', 13.37, 0.1989, Math.fround);
+testInitExpr('f64', 13.37, 0.1989, x => +x);
+
+// Int64.
+
+// Import and export
+
+// Test inner
+var initialValue = '0x123456789abcdef0';
+var nextValue = '0x531642753864975F';
+wasmAssert(`(module
+    (global (mut i64) (i64.const ${initialValue}))
+    (global i64 (i64.const ${initialValue}))
+    (func $get (result i64) (global.get 0))
+    (func $set (param i64) (global.set 0 (local.get 0)))
+    (func $get_cst (result i64) (global.get 1))
+    (export "get" (func $get))
+    (export "get_cst" (func $get_cst))
+    (export "set" (func $set))
+)`, [
+    {type: 'i64', func: '$get', expected: initialValue},
+    {type: 'i64', func: '$set', args: [`i64.const ${nextValue}`]},
+    {type: 'i64', func: '$get', expected: nextValue},
+    {type: 'i64', func: '$get_cst', expected: initialValue},
+]);
+
+// Custom NaN.
+{
+    let dv = new DataView(new ArrayBuffer(8));
+    module = wasmEvalText(`(module
+     (global $g f64 (f64.const -nan:0xe7ffff1591120))
+     (global $h f32 (f32.const -nan:0x651234))
+     (export "nan64" (global $g))(export "nan32" (global $h))
+    )`, {}).exports;
+
+    dv.setFloat64(0, module.nan64, true);
+    assertEq(dv.getUint32(4, true), 0x7ff80000);
+    assertEq(dv.getUint32(0, true), 0x00000000);
+
+    dv.setFloat32(0, module.nan32, true);
+    assertEq(dv.getUint32(0, true), 0x7fc00000);
+}
+
+// WebAssembly.Global
+{
+    const Global = WebAssembly.Global;
+
+    // These types should work:
+    assertEq(new Global({value: "i32"}) instanceof Global, true);
+    assertEq(new Global({value: "f32"}) instanceof Global, true);
+    assertEq(new Global({value: "f64"}) instanceof Global, true);
+    assertEq(new Global({value: "i64"}) instanceof Global, true); // No initial value works
+
+    // Coercion of init value; ".value" accessor
+    assertEq((new Global({value: "i32"}, 3.14)).value, 3);
+    assertEq((new Global({value: "f32"}, { valueOf: () => 33.5 })).value, 33.5);
+    assertEq((new Global({value: "f64"}, "3.25")).value, 3.25);
+
+    // Nothing special about NaN, it coerces just fine
+    assertEq((new Global({value: "i32"}, NaN)).value, 0);
+
+    // The default init value is zero.
+    assertEq((new Global({value: "i32"})).value, 0);
+    assertEq((new Global({value: "f32"})).value, 0);
+    assertEq((new Global({value: "f64"})).value, 0);
+    let mod = wasmEvalText(`(module
+                             (import "" "g" (global i64))
+                             (func (export "f") (result i32)
+                              (i64.eqz (global.get 0))))`,
+                           {"":{g: new Global({value: "i64"})}});
+    assertEq(mod.exports.f(), 1);
+
+    {
+        // "value" is enumerable
+        let x = new Global({value: "i32"});
+        let s = "";
+        for ( let i in x )
+            s = s + i + ",";
+        if (getBuildConfiguration().release_or_beta) {
+            assertEq(s, "valueOf,value,");
+        } else {
+            assertEq(s, "type,valueOf,value,");
+        }
+    }
+
+    // "value" is defined on the prototype, not on the object
+    assertEq("value" in Global.prototype, true);
+
+    // Can't set the value of an immutable global
+    assertErrorMessage(() => (new Global({value: "i32"})).value = 10,
+                       TypeError,
+                       /can't set value of immutable global/);
+
+    {
+        // Can set the value of a mutable global
+        let g = new Global({value: "i32", mutable: true}, 37);
+        g.value = 10;
+        assertEq(g.value, 10);
+    }
+
+    {
+        // Misc internal conversions
+        let g = new Global({value: "i32"}, 42);
+
+        // valueOf
+        assertEq(g - 5, 37);
+
+        // @@toStringTag
+        assertEq(g.toString(), "[object WebAssembly.Global]");
+    }
+
+    {
+        // An exported global should appear as a Global instance:
+        let i = wasmEvalText(`(module (global (export "g") i32 (i32.const 42)))`);
+
+        assertEq(typeof i.exports.g, "object");
+        assertEq(i.exports.g instanceof Global, true);
+
+        // An exported global can be imported into another instance even if
+        // it is an object:
+        let j = wasmEvalText(`(module
+                               (global (import "" "g") i32)
+                               (func (export "f") (result i32)
+                                (global.get 0)))`,
+                             { "": { "g": i.exports.g }});
+
+        // And when it is then accessed it has the right value:
+        assertEq(j.exports.f(), 42);
+    }
+
+    // Identity of Global objects (independent of mutablity).
+    {
+        // When a global is exported twice, the two objects are the same.
+        let i = wasmEvalText(`(module
+                               (global i32 (i32.const 0))
+                               (export "a" (global 0))
+                               (export "b" (global 0)))`);
+        assertEq(i.exports.a, i.exports.b);
+
+        // When a global is imported and then exported, the exported object is
+        // the same as the imported object.
+        let j = wasmEvalText(`(module
+                               (import "" "a" (global i32))
+                               (export "x" (global 0)))`,
+                             { "": {a: i.exports.a}});
+
+        assertEq(i.exports.a, j.exports.x);
+
+        // When a global is imported twice (ie aliased) and then exported twice,
+        // the exported objects are the same, and are also the same as the
+        // imported object.
+        let k = wasmEvalText(`(module
+                               (import "" "a" (global i32))
+                               (import "" "b" (global i32))
+                               (export "x" (global 0))
+                               (export "y" (global 1)))`,
+                             { "": {a: i.exports.a,
+                                    b: i.exports.a}});
+
+        assertEq(i.exports.a, k.exports.x);
+        assertEq(k.exports.x, k.exports.y);
+    }
+
+    // Mutability
+    {
+        let i = wasmEvalText(`(module
+                               (global (export "g") (mut i32) (i32.const 37))
+                               (func (export "getter") (result i32)
+                                (global.get 0))
+                               (func (export "setter") (param i32)
+                                (global.set 0 (local.get 0))))`);
+
+        let j = wasmEvalText(`(module
+                               (import "" "g" (global (mut i32)))
+                               (func (export "getter") (result i32)
+                                (global.get 0))
+                               (func (export "setter") (param i32)
+                                (global.set 0 (local.get 0))))`,
+                             {"": {g: i.exports.g}});
+
+        // Initial values
+        assertEq(i.exports.g.value, 37);
+        assertEq(i.exports.getter(), 37);
+        assertEq(j.exports.getter(), 37);
+
+        // Set in i, observe everywhere
+        i.exports.setter(42);
+
+        assertEq(i.exports.g.value, 42);
+        assertEq(i.exports.getter(), 42);
+        assertEq(j.exports.getter(), 42);
+
+        // Set in j, observe everywhere
+        j.exports.setter(78);
+
+        assertEq(i.exports.g.value, 78);
+        assertEq(i.exports.getter(), 78);
+        assertEq(j.exports.getter(), 78);
+
+        // Set on global object, observe everywhere
+        i.exports.g.value = 197;
+
+        assertEq(i.exports.g.value, 197);
+        assertEq(i.exports.getter(), 197);
+        assertEq(j.exports.getter(), 197);
+    }
+
+    // Mutability of import declaration and imported value have to match
+    {
+        const mutErr = /imported global mutability mismatch/;
+
+        let m1 = new Module(wasmTextToBinary(`(module
+                                               (import "m" "g" (global i32)))`));
+
+        // Mutable Global matched to immutable import
+        let gm = new Global({value: "i32", mutable: true}, 42);
+        assertErrorMessage(() => new Instance(m1, {m: {g: gm}}),
+                           LinkError,
+                           mutErr);
+
+        let m2 = new Module(wasmTextToBinary(`(module
+                                               (import "m" "g" (global (mut i32))))`));
+
+        // Immutable Global matched to mutable import
+        let gi = new Global({value: "i32", mutable: false}, 42);
+        assertErrorMessage(() => new Instance(m2, {m: {g: gi}}),
+                           LinkError,
+                           mutErr);
+
+        // Constant value is the same as immutable Global
+        assertErrorMessage(() => new Instance(m2, {m: {g: 42}}),
+                           LinkError,
+                           mutErr);
+    }
+
+    // TEST THIS LAST
+
+    // "value" is deletable
+    assertEq(delete Global.prototype.value, true);
+    assertEq("value" in Global.prototype, false);
+
+    // ADD NO MORE TESTS HERE!
+}
+
+// Standard wat syntax: the parens around the initializer expression are
+// optional.
+{
+    let i1 = wasmEvalText(
+        `(module
+           (global $g i32 i32.const 37)
+           (func (export "f") (result i32) (global.get $g)))`);
+    assertEq(i1.exports.f(), 37);
+
+    let i2 = wasmEvalText(
+        `(module
+           (global $g (mut f64) f64.const 42.0)
+           (func (export "f") (result f64) (global.get $g)))`);
+    assertEq(i2.exports.f(), 42);
+
+    let i3 = wasmEvalText(
+        `(module
+           (global $x (import "m" "x") i32)
+           (global $g i32 global.get $x)
+           (func (export "f") (result i32) (global.get $g)))`,
+        {m:{x:86}});
+    assertEq(i3.exports.f(), 86);
+}
diff --git a/js/src/jit-test/tests/wasm/grow-memory.js b/js/src/jit-test/tests/wasm/grow-memory.js
new file mode 100644
index 0000000000..a5022792ff
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/grow-memory.js
@@ -0,0 +1,46 @@
+function linearModule(min, max, ops, current_memory, grow_memory) {
+  var opsText = ops.map(function (op) {
+    if (op[0] == "CM") {
+      res = `(if (result i32) (i32.ne (${current_memory}) (i32.const ${op[1]}))
+                  (i32.load offset=10 (i32.const 4294967295))
+                  (i32.const 0))`
+    } else if (op[0] == "GM") {
+      res = `(if (result i32) (i32.ne (${grow_memory} (i32.const ${op[1]})) (i32.const ${op[2]}))
+                 (i32.load offset=10 (i32.const 4294967295))
+                 (i32.const 0))`
+    } else if (op[0] == "L") {
+      var type = op[1];
+      var ext = op[2];
+      var off = op[3];
+      var loc = op[4]
+      var align = 0;
+      res = `(${type}.load${ext} offset=${off} (i32.const ${op[4]}))`;
+    } else if (op[0] == "S") {
+      var type = op[1];
+      var ext = op[2];
+      var off = op[3];
+      var loc = op[4]
+      var align = 0;
+      res = `(${type}.store${ext} offset=${off} (i32.const ${op[4]}) (i32.const 42))`;
+    }
+    return res;
+  }).join("\n")
+
+  let text =
+    `(module
+       (memory ${min} ${max})
+         ` + (min != 0 ? `(data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f")
+                          (data (i32.const 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")`
+                      : "") +
+       `
+       (func (result i32)
+         (drop ` + opsText + `)
+         (${current_memory})
+       ) (export "run" (func 0)))`;
+
+  return text;
+}
+
+// Just grow some memory
+wasmFullPass(linearModule(3,5, [["CM", 3]], "current_memory", "grow_memory"), 3); // Old opcode names
+wasmFullPass(linearModule(3,5, [["CM", 3]], "memory.size", "memory.grow"), 3);    // New opcode names
diff --git a/js/src/jit-test/tests/wasm/import-callables.js b/js/src/jit-test/tests/wasm/import-callables.js
new file mode 100644
index 0000000000..9053baa575
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/import-callables.js
@@ -0,0 +1,55 @@
+// Test importing callable object types other than plain functions.
+
+// Wasm function equivalent to: function run(x) { return timesSeven(x) + 3; }
+let bytes = wasmTextToBinary(`
+   (module
+    (func $timesSeven (import "imports" "timesSeven")
+        (param i32) (result i32))
+    (func $run (export "run") (param i32) (result i32)
+         local.get 0
+         call $timesSeven
+         i32.const 3
+         i32.add))`);
+let mod = new WebAssembly.Module(bytes);
+
+function test(timesSeven) {
+    let inst = new WebAssembly.Instance(mod, {imports: {timesSeven}});
+    return inst.exports.run(1) + inst.exports.run(3);
+}
+
+// Various supported callables.
+let timesSeven = x => x * 7;
+assertEq(test(timesSeven), 34);
+assertEq(test(timesSeven.bind(null)), 34);
+assertEq(test(timesSeven.bind(null, 4)), 62);
+assertEq(test(new Proxy(timesSeven, {})), 34);
+assertEq(test(wrapWithProto(timesSeven, null)), 34);
+
+// Test proxy `apply` trap.
+let traps = [];
+assertEq(test(new Proxy(timesSeven, {apply(target, thisArg, args) {
+    traps.push(arguments);
+    return 5;
+}})), 16);
+assertEq(traps.length, 2);
+for (let trap of traps) {
+    assertEq(trap[0], timesSeven); // target
+    assertEq(trap[1], undefined);  // thisArg
+    assertEq(trap[2].length, 1);   // args
+}
+
+function testThrowsLinkError(f) {
+    assertErrorMessage(() => test(f), WebAssembly.LinkError, /is not a Function/);
+}
+
+// Non-callables.
+testThrowsLinkError({});
+testThrowsLinkError(null);
+testThrowsLinkError(this);
+testThrowsLinkError(new Proxy({}, {}));
+testThrowsLinkError(wrapWithProto({}, null));
+
+// Cross-compartment wrappers are currently not supported.
+let g = newGlobal({newCompartment: true});
+g.evaluate(`function timesSeven(x) { return x * 7; }`);
+testThrowsLinkError(g.timesSeven);
diff --git a/js/src/jit-test/tests/wasm/import-export-sigs.js b/js/src/jit-test/tests/wasm/import-export-sigs.js
new file mode 100644
index 0000000000..8765d56b15
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/import-export-sigs.js
@@ -0,0 +1,52 @@
+// |jit-test| skip-if: fuzzingSafe()
+
+// Tests that function imports and function exports descriptors have
+// signatures, in the test mode only, for fuzzers.
+
+var module = new WebAssembly.Module(wasmTextToBinary(`(module
+  (import "env" "v_v" (func $vv))
+  (export "v_v" (func $vv))
+
+  (import "env" "v_i" (func $vi (param i32)))
+  (export "v_i" (func $vi))
+
+  (import "env" "v_I" (func $vI (param i64)))
+  (export "v_I" (func $vI))
+
+  (import "env" "v_f" (func $vf (param f32)))
+  (export "v_f" (func $vf))
+
+  (import "env" "memory" (memory $mem 0))
+  (export "mem" (memory $mem))
+
+  (import "env" "v_d" (func $vd (param f64)))
+  (export "v_d" (func $vd))
+
+  (import "env" "v_fd" (func $vfd (param f32) (param f64)))
+  (export "v_fd" (func $vfd))
+
+  (import "env" "v_Ififd" (func $vIfifd (param i64) (param f32) (param i32) (param f32) (param f64)))
+  (export "v_Ififd" (func $vIfifd))
+
+  (import "env" "i_v" (func $iv (result i32)))
+  (export "i_v" (func $iv))
+
+  (import "env" "I_i" (func $Ii (param i32) (result i64)))
+  (export "I_i" (func $Ii))
+
+  (import "env" "table" (table $table 0 funcref))
+  (export "table" (table $table))
+
+  (import "env" "f_d" (func $fd (param f64) (result f32)))
+  (export "f_d" (func $fd))
+
+  (import "env" "d_ffd" (func $dffd (param f32) (param f32) (param f64) (result f64)))
+  (export "d_ffd" (func $dffd))
+)`));
+
+for (let desc of WebAssembly.Module.imports(module)) {
+    assertEq(typeof desc.signature, 'undefined');
+}
+for (let desc of WebAssembly.Module.exports(module)) {
+    assertEq(typeof desc.signature, 'undefined');
+}
diff --git a/js/src/jit-test/tests/wasm/import-export.js b/js/src/jit-test/tests/wasm/import-export.js
new file mode 100644
index 0000000000..6b858f3089
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/import-export.js
@@ -0,0 +1,798 @@
+const { Module, Instance, Memory, Table, LinkError, RuntimeError } = WebAssembly;
+
+const mem1Page = new Memory({initial:1});
+const mem1PageMax1 = new Memory({initial:1, maximum: 1});
+const mem2Page = new Memory({initial:2});
+const mem2PageMax2 = new Memory({initial:2, maximum: 2});
+const mem2PageMax3 = new Memory({initial:2, maximum: 3});
+const mem2PageMax4 = new Memory({initial:2, maximum: 4});
+const mem3Page = new Memory({initial:3});
+const mem3PageMax3 = new Memory({initial:3, maximum: 3});
+const mem4Page = new Memory({initial:4});
+const mem4PageMax4 = new Memory({initial:4, maximum: 4});
+const tab1Elem = new Table({initial:1, element:"anyfunc"});
+const tab2Elem = new Table({initial:2, element:"anyfunc"});
+const tab3Elem = new Table({initial:3, element:"anyfunc"});
+const tab4Elem = new Table({initial:4, element:"anyfunc"});
+
+function assertSegmentFitError(f) {
+    assertErrorMessage(f, RuntimeError, /out of bounds/);
+}
+
+const m1 = new Module(wasmTextToBinary('(module (import "foo" "bar" (func)) (import "baz" "quux" (func)))'));
+assertErrorMessage(() => new Instance(m1), TypeError, /second argument must be an object/);
+assertErrorMessage(() => new Instance(m1, {foo:null}), TypeError, /import object field 'foo' is not an Object/);
+assertErrorMessage(() => new Instance(m1, {foo:{bar:{}}}), LinkError, /import object field 'bar' is not a Function/);
+assertErrorMessage(() => new Instance(m1, {foo:{bar:()=>{}}, baz:null}), TypeError, /import object field 'baz' is not an Object/);
+assertErrorMessage(() => new Instance(m1, {foo:{bar:()=>{}}, baz:{}}), LinkError, /import object field 'quux' is not a Function/);
+assertEq(new Instance(m1, {foo:{bar:()=>{}}, baz:{quux:()=>{}}}) instanceof Instance, true);
+
+const m2 = new Module(wasmTextToBinary('(module (import "x" "y" (memory 2 3)))'));
+assertErrorMessage(() => new Instance(m2), TypeError, /second argument must be an object/);
+assertErrorMessage(() => new Instance(m2, {x:null}), TypeError, /import object field 'x' is not an Object/);
+assertErrorMessage(() => new Instance(m2, {x:{y:{}}}), LinkError, /import object field 'y' is not a Memory/);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem1Page}}), LinkError, /imported Memory with incompatible size/);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem1PageMax1}}), LinkError, /imported Memory with incompatible size/);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem4Page}}), LinkError, /imported Memory with incompatible size/);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem4PageMax4}}), LinkError, /imported Memory with incompatible size/);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem2Page}}), LinkError, /imported Memory with incompatible maximum size/);
+assertEq(new Instance(m2, {x:{y:mem2PageMax2}}) instanceof Instance, true);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem3Page}}), LinkError, /imported Memory with incompatible maximum size/);
+assertEq(new Instance(m2, {x:{y:mem3PageMax3}}) instanceof Instance, true);
+assertEq(new Instance(m2, {x:{y:mem2PageMax3}}) instanceof Instance, true);
+assertErrorMessage(() => new Instance(m2, {x:{y:mem2PageMax4}}), LinkError, /imported Memory with incompatible maximum size/);
+
+const m3 = new Module(wasmTextToBinary('(module (import "foo" "bar" (memory 1 1)) (import "baz" "quux" (func)))'));
+assertErrorMessage(() => new Instance(m3), TypeError, /second argument must be an object/);
+assertErrorMessage(() => new Instance(m3, {foo:null}), TypeError, /import object field 'foo' is not an Object/);
+assertErrorMessage(() => new Instance(m3, {foo:{bar:{}}}), LinkError, /import object field 'bar' is not a Memory/);
+assertErrorMessage(() => new Instance(m3, {foo:{bar:mem1Page}, baz:null}), TypeError, /import object field 'baz' is not an Object/);
+assertErrorMessage(() => new Instance(m3, {foo:{bar:mem1Page}, baz:{quux:mem1Page}}), LinkError, /import object field 'quux' is not a Function/);
+assertErrorMessage(() => new Instance(m3, {foo:{bar:mem1Page}, baz:{quux:()=>{}}}), LinkError, /imported Memory with incompatible maximum size/);
+assertEq(new Instance(m3, {foo:{bar:mem1PageMax1}, baz:{quux:()=>{}}}) instanceof Instance, true);
+
+const m4 = new Module(wasmTextToBinary('(module (import "baz" "quux" (func)) (import "foo" "bar" (memory 1 1)))'));
+assertErrorMessage(() => new Instance(m4), TypeError, /second argument must be an object/);
+assertErrorMessage(() => new Instance(m4, {baz:null}), TypeError, /import object field 'baz' is not an Object/);
+assertErrorMessage(() => new Instance(m4, {baz:{quux:{}}}), LinkError, /import object field 'quux' is not a Function/);
+assertErrorMessage(() => new Instance(m4, {baz:{quux:()=>{}}, foo:null}), TypeError, /import object field 'foo' is not an Object/);
+assertErrorMessage(() => new Instance(m4, {baz:{quux:()=>{}}, foo:{bar:()=>{}}}), LinkError, /import object field 'bar' is not a Memory/);
+assertErrorMessage(() => new Instance(m4, {baz:{quux:()=>{}}, foo:{bar:mem1Page}}), LinkError, /imported Memory with incompatible maximum size/);
+assertEq(new Instance(m3, {baz:{quux:()=>{}}, foo:{bar:mem1PageMax1}}) instanceof Instance, true);
+
+const m5 = new Module(wasmTextToBinary('(module (import "a" "b" (memory 2)))'));
+assertErrorMessage(() => new Instance(m5, {a:{b:mem1Page}}), LinkError, /imported Memory with incompatible size/);
+assertEq(new Instance(m5, {a:{b:mem2Page}}) instanceof Instance, true);
+assertEq(new Instance(m5, {a:{b:mem3Page}}) instanceof Instance, true);
+assertEq(new Instance(m5, {a:{b:mem4Page}}) instanceof Instance, true);
+
+const m6 = new Module(wasmTextToBinary('(module (import "a" "b" (table 2 funcref)))'));
+assertErrorMessage(() => new Instance(m6, {a:{b:tab1Elem}}), LinkError, /imported Table with incompatible size/);
+assertEq(new Instance(m6, {a:{b:tab2Elem}}) instanceof Instance, true);
+assertEq(new Instance(m6, {a:{b:tab3Elem}}) instanceof Instance, true);
+assertEq(new Instance(m6, {a:{b:tab4Elem}}) instanceof Instance, true);
+
+const m7 = new Module(wasmTextToBinary('(module (import "a" "b" (table 2 3 funcref)))'));
+assertErrorMessage(() => new Instance(m7, {a:{b:tab1Elem}}), LinkError, /imported Table with incompatible size/);
+assertErrorMessage(() => new Instance(m7, {a:{b:tab2Elem}}), LinkError, /imported Table with incompatible maximum size/);
+assertErrorMessage(() => new Instance(m7, {a:{b:tab3Elem}}), LinkError, /imported Table with incompatible maximum size/);
+assertErrorMessage(() => new Instance(m7, {a:{b:tab4Elem}}), LinkError, /imported Table with incompatible size/);
+
+wasmFailValidateText('(module (memory 2 1))', /maximum length 1 is less than initial length 2/);
+wasmFailValidateText('(module (import "a" "b" (memory 2 1)))', /maximum length 1 is less than initial length 2/);
+wasmFailValidateText('(module (table 2 1 funcref))', /maximum length 1 is less than initial length 2/);
+wasmFailValidateText('(module (import "a" "b" (table 2 1 funcref)))', /maximum length 1 is less than initial length 2/);
+
+// Import wasm-wasm type mismatch
+
+var e = wasmEvalText('(module (func $i2v (param i32)) (export "i2v" (func $i2v)) (func $f2v (param f32)) (export "f2v" (func $f2v)))').exports;
+var i2vm = new Module(wasmTextToBinary('(module (import "a" "b" (func (param i32))))'));
+var f2vm = new Module(wasmTextToBinary('(module (import "a" "b" (func (param f32))))'));
+assertEq(new Instance(i2vm, {a:{b:e.i2v}}) instanceof Instance, true);
+assertErrorMessage(() => new Instance(i2vm, {a:{b:e.f2v}}), LinkError, /imported function 'a.b' signature mismatch/);
+assertErrorMessage(() => new Instance(f2vm, {a:{b:e.i2v}}), LinkError, /imported function 'a.b' signature mismatch/);
+assertEq(new Instance(f2vm, {a:{b:e.f2v}}) instanceof Instance, true);
+var l2vm = new Module(wasmTextToBinary('(module (import "x" "y" (memory 1)) (import "c" "d" (func (param i64))))'));
+assertErrorMessage(() => new Instance(l2vm, {x:{y:mem1Page}, c:{d:e.i2v}}), LinkError, /imported function 'c.d' signature mismatch/);
+
+// Import order:
+
+var arr = [];
+var importObj = {
+    get foo() { arr.push("foo") },
+    get baz() { arr.push("bad") },
+};
+assertErrorMessage(() => new Instance(m1, importObj), TypeError, /import object field 'foo' is not an Object/);
+assertEq(arr.join(), "foo");
+
+var arr = [];
+var importObj = {
+    get foo() {
+        arr.push("foo");
+        return { get bar() { arr.push("bar"); return null } }
+    },
+    get baz() { arr.push("bad") },
+};
+assertErrorMessage(() => new Instance(m1, importObj), LinkError, /import object field 'bar' is not a Function/);
+assertEq(arr.join(), "foo,bar");
+
+var arr = [];
+var importObj = {
+    get foo() {
+        arr.push("foo");
+        return { get bar() { arr.push("bar"); return () => arr.push("bad") } }
+    },
+    get baz() {
+        arr.push("baz");
+        return { get quux() { arr.push("quux"); return () => arr.push("bad") } }
+    }
+};
+assertEq(new Instance(m1, importObj) instanceof Instance, true);
+assertEq(arr.join(), "foo,bar,baz,quux");
+
+var arr = [];
+var importObj = {
+    get foo() {
+        arr.push("foo");
+        return { get bar() { arr.push("bar"); return new WebAssembly.Memory({initial:1, maximum:1}) } }
+    },
+    get baz() {
+        arr.push("baz");
+        return { get quux() { arr.push("quux"); return () => arr.push("bad") } }
+    }
+};
+assertEq(new Instance(m3, importObj) instanceof Instance, true);
+assertEq(arr.join(), "foo,bar,baz,quux");
+arr = [];
+assertEq(new Instance(m4, importObj) instanceof Instance, true);
+assertEq(arr.join(), "baz,quux,foo,bar");
+
+// Export key order:
+
+var code = wasmTextToBinary('(module)');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).length, 0);
+
+var code = wasmTextToBinary('(module (func) (export "foo" (func 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "foo");
+assertEq(e.foo(), undefined);
+
+var code = wasmTextToBinary('(module (func) (export "foo" (func 0)) (export "bar" (func 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "foo,bar");
+assertEq(e.foo(), undefined);
+assertEq(e.bar(), undefined);
+assertEq(e.foo, e.bar);
+
+var code = wasmTextToBinary('(module (memory 1 1) (export "memory" (memory 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "memory");
+
+var code = wasmTextToBinary('(module (memory 1 1) (export "foo" (memory 0)) (export "bar" (memory 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "foo,bar");
+assertEq(e.foo, e.bar);
+assertEq(e.foo instanceof Memory, true);
+assertEq(e.foo.buffer.byteLength, 64*1024);
+
+var code = wasmTextToBinary('(module (memory 1 1) (func) (export "foo" (func 0)) (export "bar" (memory 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "foo,bar");
+assertEq(e.foo(), undefined);
+assertEq(e.bar instanceof Memory, true);
+assertEq(e.bar instanceof Memory, true);
+assertEq(e.bar.buffer.byteLength, 64*1024);
+
+var code = wasmTextToBinary('(module (memory 1 1) (func) (export "bar" (memory 0)) (export "foo" (func 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "bar,foo");
+assertEq(e.foo(), undefined);
+assertEq(e.bar.buffer.byteLength, 64*1024);
+
+var code = wasmTextToBinary('(module (memory 1 1) (export "" (memory 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).length, 1);
+assertEq(String(Object.keys(e)), "");
+assertEq(e[""] instanceof Memory, true);
+
+var code = wasmTextToBinary('(module (table 0 funcref) (export "tbl" (table 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "tbl");
+assertEq(e.tbl instanceof Table, true);
+assertEq(e.tbl.length, 0);
+
+var code = wasmTextToBinary('(module (table 2 funcref) (export "t1" (table 0)) (export "t2" (table 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "t1,t2");
+assertEq(e.t1 instanceof Table, true);
+assertEq(e.t2 instanceof Table, true);
+assertEq(e.t1, e.t2);
+assertEq(e.t1.length, 2);
+
+var code = wasmTextToBinary('(module (table 2 funcref) (memory 1 1) (func) (export "t" (table 0)) (export "m" (memory 0)) (export "f" (func 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "t,m,f");
+assertEq(e.f(), undefined);
+assertEq(e.t instanceof Table, true);
+assertEq(e.m instanceof Memory, true);
+assertEq(e.t.length, 2);
+
+var code = wasmTextToBinary('(module (table 1 funcref) (memory 1 1) (func) (export "m" (memory 0)) (export "f" (func 0)) (export "t" (table 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).join(), "m,f,t");
+assertEq(e.f(), undefined);
+assertEq(e.t instanceof Table, true);
+assertEq(e.m instanceof Memory, true);
++assertEq(e.t.length, 1);
+
+var code = wasmTextToBinary('(module (table 0 funcref) (export "" (table 0)))');
+var e = new Instance(new Module(code)).exports;
+assertEq(Object.keys(e).length, 1);
+assertEq(String(Object.keys(e)), "");
+assertEq(e[""] instanceof Table, true);
++assertEq(e[""].length, 0);
+
+// Table export function identity
+
+var text = `(module
+    (func $f (result i32) (i32.const 1))
+    (func $g (result i32) (i32.const 2))
+    (func $h (result i32) (i32.const 3))
+    (table 4 funcref)
+    (elem (i32.const 0) $f)
+    (elem (i32.const 2) $g)
+    (export "f1" (func $f))
+    (export "tbl1" (table 0))
+    (export "f2" (func $f))
+    (export "tbl2" (table 0))
+    (export "f3" (func $h))
+    (func (export "run") (result i32) (call_indirect (type 0) (i32.const 2)))
+)`;
+wasmFullPass(text, 2);
+var e = new Instance(new Module(wasmTextToBinary(text))).exports;
+assertEq(String(Object.keys(e)), "f1,tbl1,f2,tbl2,f3,run");
+assertEq(e.f1, e.f2);
+assertEq(e.f1(), 1);
+assertEq(e.f3(), 3);
+assertEq(e.tbl1, e.tbl2);
+assertEq(e.tbl1.get(0), e.f1);
+assertEq(e.tbl1.get(0), e.tbl1.get(0));
+assertEq(e.tbl1.get(0)(), 1);
+assertEq(e.tbl1.get(1), null);
+assertEq(e.tbl1.get(2), e.tbl1.get(2));
+assertEq(e.tbl1.get(2)(), 2);
+assertEq(e.tbl1.get(3), null);
+assertErrorMessage(() => e.tbl1.get(4), RangeError, /bad Table get index/);
+assertEq(e.tbl1.get(1), null);
+e.tbl1.set(1, e.f3);
+assertEq(e.tbl1.get(1), e.f3);
+e.tbl1.set(1, null);
+assertEq(e.tbl1.get(1), null);
+e.tbl1.set(3, e.f1);
+assertEq(e.tbl1.get(0), e.tbl1.get(3));
+
+// JS re-exports
+
+var args;
+var m = new Module(wasmTextToBinary(`(module
+    (export "a" (func $a)) (import "" "a" (func $a (param f32)))
+    (export "b" (func $b)) (import "" "b" (func $b (param i32) (result i32)))
+    (export "c" (func $c)) (import "" "c" (func $c (result i32)))
+    (export "d" (func $d)) (import "" "d" (func $d))
+)`));
+var js = function() { args = arguments; return 42 }
+var e = new Instance(m, {"":{a:js, b:js, c:js, d:js}}).exports;
+assertEq(e.a.length, 1);
+assertEq(e.a(), undefined);
+assertEq(args.length, 1);
+assertEq(args[0], NaN);
+assertEq(e.a(99.5), undefined);
+assertEq(args.length, 1);
+assertEq(args[0], 99.5);
+assertEq(e.b.length, 1);
+assertEq(e.b(), 42);
+assertEq(args.length, 1);
+assertEq(args[0], 0);
+assertEq(e.b(99.5), 42);
+assertEq(args.length, 1);
+assertEq(args[0], 99);
+assertEq(e.c.length, 0);
+assertEq(e.c(), 42);
+assertEq(args.length, 0);
+assertEq(e.c(99), 42);
+assertEq(args.length, 0);
+assertEq(e.d.length, 0);
+assertEq(e.d(), undefined);
+assertEq(args.length, 0);
+assertEq(e.d(99), undefined);
+assertEq(args.length, 0);
+
+// Re-exports and Identity:
+
+var code = wasmTextToBinary('(module (import "a" "b" (memory 1 1)) (export "foo" (memory 0)) (export "bar" (memory 0)))');
+var mem = new Memory({initial:1, maximum:1});
+var e = new Instance(new Module(code), {a:{b:mem}}).exports;
+assertEq(mem, e.foo);
+assertEq(mem, e.bar);
+
+var code = wasmTextToBinary('(module (import "a" "b" (table 1 1 funcref)) (export "foo" (table 0)) (export "bar" (table 0)))');
+var tbl = new Table({initial:1, maximum:1, element:"anyfunc"});
+var e = new Instance(new Module(code), {a:{b:tbl}}).exports;
+assertEq(tbl, e.foo);
+assertEq(tbl, e.bar);
+
+var code = wasmTextToBinary('(module (import "a" "b" (table 2 2 funcref)) (func $foo) (elem (i32.const 0) $foo) (export "foo" (func $foo)))');
+var tbl = new Table({initial:2, maximum:2, element:"anyfunc"});
+var e1 = new Instance(new Module(code), {a:{b:tbl}}).exports;
+assertEq(e1.foo, tbl.get(0));
+tbl.set(1, e1.foo);
+assertEq(e1.foo, tbl.get(1));
+var e2 = new Instance(new Module(code), {a:{b:tbl}}).exports;
+assertEq(e2.foo, tbl.get(0));
+assertEq(e1.foo, tbl.get(1));
+assertEq(tbl.get(0) === e1.foo, false);
+assertEq(e1.foo === e2.foo, false);
+
+var m = new Module(wasmTextToBinary(`(module
+    (import "" "foo" (func $foo (result i32)))
+    (import "" "bar" (func $bar (result i32)))
+    (table 3 funcref)
+    (func $baz (result i32) (i32.const 13))
+    (elem (i32.const 0) $foo $bar $baz)
+    (export "foo" (func $foo))
+    (export "bar" (func $bar))
+    (export "baz" (func $baz))
+    (export "tbl" (table 0))
+)`));
+var jsFun = () => 83;
+var wasmFun = new Instance(new Module(wasmTextToBinary('(module (func (result i32) (i32.const 42)) (export "foo" (func 0)))'))).exports.foo;
+var e1 = new Instance(m, {"":{foo:jsFun, bar:wasmFun}}).exports;
+assertEq(jsFun === e1.foo, false);
+assertEq(wasmFun, e1.bar);
+assertEq(e1.foo, e1.tbl.get(0));
+assertEq(e1.bar, e1.tbl.get(1));
+assertEq(e1.baz, e1.tbl.get(2));
+assertEq(e1.tbl.get(0)(), 83);
+assertEq(e1.tbl.get(1)(), 42);
+assertEq(e1.tbl.get(2)(), 13);
+var e2 = new Instance(m, {"":{foo:jsFun, bar:jsFun}}).exports;
+assertEq(jsFun === e2.foo, false);
+assertEq(jsFun === e2.bar, false);
+assertEq(e2.foo === e1.foo, false);
+assertEq(e2.bar === e1.bar, false);
+assertEq(e2.baz === e1.baz, false);
+assertEq(e2.tbl === e1.tbl, false);
+assertEq(e2.foo, e2.tbl.get(0));
+assertEq(e2.bar, e2.tbl.get(1));
+assertEq(e2.baz, e2.tbl.get(2));
+var e3 = new Instance(m, {"":{foo:wasmFun, bar:wasmFun}}).exports;
+assertEq(wasmFun, e3.foo);
+assertEq(wasmFun, e3.bar);
+assertEq(e3.baz === e3.foo, false);
+assertEq(e3.baz === e1.baz, false);
+assertEq(e3.tbl === e1.tbl, false);
+assertEq(e3.foo, e3.tbl.get(0));
+assertEq(e3.bar, e3.tbl.get(1));
+assertEq(e3.baz, e3.tbl.get(2));
+var e4 = new Instance(m, {"":{foo:e1.foo, bar:e1.foo}}).exports;
+assertEq(e4.foo, e1.foo);
+assertEq(e4.bar, e1.foo);
+assertEq(e4.baz === e4.foo, false);
+assertEq(e4.baz === e1.baz, false);
+assertEq(e4.tbl === e1.tbl, false);
+assertEq(e4.foo, e4.tbl.get(0));
+assertEq(e4.foo, e4.tbl.get(1));
+assertEq(e4.baz, e4.tbl.get(2));
+
+// i64 is fully allowed for imported wasm functions
+
+var code1 = wasmTextToBinary('(module (func $exp (param i64) (result i64) (i64.add (local.get 0) (i64.const 10))) (export "exp" (func $exp)))');
+var e1 = new Instance(new Module(code1)).exports;
+var code2 = wasmTextToBinary('(module (import "a" "b" (func $i (param i64) (result i64))) (func $f (result i32) (i32.wrap/i64 (call $i (i64.const 42)))) (export "f" (func $f)))');
+var e2 = new Instance(new Module(code2), {a:{b:e1.exp}}).exports;
+assertEq(e2.f(), 52);
+
+// Non-existent export errors
+
+wasmFailValidateText('(module (export "a" (func 0)))', /exported function index out of bounds/);
+wasmFailValidateText('(module (export "a" (global 0)))', /exported global index out of bounds/);
+wasmFailValidateText('(module (export "a" (memory 0)))', /exported memory index out of bounds/);
+wasmFailValidateText('(module (export "a" (table 0)))', /exported table index out of bounds/);
+
+// Default memory/table rules
+
+wasmFailValidateText('(module (import "a" "b" (memory 1 1)) (memory 1 1))', /already have default memory/);
+wasmFailValidateText('(module (import "a" "b" (memory 1 1)) (import "x" "y" (memory 2 2)))', /already have default memory/);
+
+// Data segments on imports
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (import "a" "b" (memory 1 1))
+        (data (i32.const 0) "\\0a\\0b")
+        (data (i32.const 100) "\\0c\\0d")
+        (func $get (param $p i32) (result i32)
+            (i32.load8_u (local.get $p)))
+        (export "get" (func $get)))
+`));
+var mem = new Memory({initial:1, maximum:1});
+var {get} = new Instance(m, {a:{b:mem}}).exports;
+assertEq(get(0), 0xa);
+assertEq(get(1), 0xb);
+assertEq(get(2), 0x0);
+assertEq(get(100), 0xc);
+assertEq(get(101), 0xd);
+assertEq(get(102), 0x0);
+var i8 = new Uint8Array(mem.buffer);
+assertEq(i8[0], 0xa);
+assertEq(i8[1], 0xb);
+assertEq(i8[2], 0x0);
+assertEq(i8[100], 0xc);
+assertEq(i8[101], 0xd);
+assertEq(i8[102], 0x0);
+
+// Data segments with imported offsets
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (import "glob" "a" (global i32))
+        (memory 1)
+        (data (global.get 0) "\\0a\\0b"))
+`));
+assertEq(new Instance(m, {glob:{a:0}}) instanceof Instance, true);
+assertEq(new Instance(m, {glob:{a:(64*1024 - 2)}}) instanceof Instance, true);
+assertSegmentFitError(() => new Instance(m, {glob:{a:(64*1024 - 1)}}));
+assertSegmentFitError(() => new Instance(m, {glob:{a:64*1024}}));
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (memory 1)
+        (data (i32.const 0x10001) "\\0a\\0b"))
+`));
+assertSegmentFitError(() => new Instance(m));
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (memory 0)
+        (data (i32.const 0x10001) ""))
+`));
+assertSegmentFitError(() => new Instance(m));
+
+// Errors during segment initialization do not have observable effects
+// and are checked against the actual memory/table length, not the declared
+// initial length.
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (import "a" "mem" (memory 1))
+        (import "a" "tbl" (table 1 funcref))
+        (import "a" "memOff" (global $memOff i32))
+        (import "a" "tblOff" (global $tblOff i32))
+        (func $f)
+        (func $g)
+        (data (i32.const 0) "\\01")
+        (elem (i32.const 0) $f)
+        (data (global.get $memOff) "\\02")
+        (elem (global.get $tblOff) $g)
+        (export "f" (func $f))
+        (export "g" (func $g)))
+`));
+
+// Active segments are applied in order (this is observable if they overlap).
+//
+// Without bulk memory, all range checking for tables and memory happens before
+// any writes happen, and any OOB will force no writing to happen at all.
+//
+// With bulk memory, active segments are applied first for tables and then for
+// memories.  Bounds checking happens for each byte or table element written.
+// The first OOB aborts the initialization process, leaving written data in
+// place.  Notably, any OOB in table initialization will prevent any memory
+// initialization from happening at all.
+
+var npages = 2;
+var mem = new Memory({initial:npages});
+var mem8 = new Uint8Array(mem.buffer);
+var tbl = new Table({initial:2, element:"anyfunc"});
+
+assertSegmentFitError(() => new Instance(m, {a:{mem, tbl, memOff:1, tblOff:2}}));
+// The first active element segment is applied, but the second active
+// element segment is completely OOB.
+assertEq(typeof tbl.get(0), "function");
+assertEq(tbl.get(1), null);
+
+assertEq(mem8[0], 0);
+assertEq(mem8[1], 0);
+
+tbl.set(0, null);
+tbl.set(1, null);
+
+assertSegmentFitError(() => new Instance(m, {a:{mem, tbl, memOff:npages*64*1024, tblOff:1}}));
+// The first and second active element segments are applied fully.  The
+// first active data segment applies, but the second one is completely OOB.
+assertEq(typeof tbl.get(0), "function");
+assertEq(typeof tbl.get(1), "function");
+assertEq(mem8[0], 1);
+
+tbl.set(0, null);
+tbl.set(1, null);
+mem8[0] = 0;
+
+// Both element and data segments apply successfully without OOB
+
+var i = new Instance(m, {a:{mem, tbl, memOff:npages*64*1024-1, tblOff:1}});
+assertEq(mem8[0], 1);
+assertEq(mem8[npages*64*1024-1], 2);
+assertEq(tbl.get(0), i.exports.f);
+assertEq(tbl.get(1), i.exports.g);
+
+// Element segment doesn't apply and prevents subsequent elem segment and
+// data segment from being applied.
+
+var m = new Module(wasmTextToBinary(
+    `(module
+       (import "" "mem" (memory 1))
+       (import "" "tbl" (table 3 funcref))
+       (elem (i32.const 1) $f $g $h) ;; fails after $f and $g
+       (elem (i32.const 0) $f)       ;; is not applied
+       (data (i32.const 0) "\\01")   ;; is not applied
+       (func $f)
+       (func $g)
+       (func $h))`));
+var mem = new Memory({initial:1});
+var tbl = new Table({initial:3, element:"anyfunc"});
+assertSegmentFitError(() => new Instance(m, {"":{mem, tbl}}));
+assertEq(tbl.get(0), null);
+assertEq(tbl.get(1), null);
+assertEq(tbl.get(2), null);
+var v = new Uint8Array(mem.buffer);
+assertEq(v[0], 0);
+
+// Data segment doesn't apply and prevents subsequent data segment from
+// being applied.
+
+var m = new Module(wasmTextToBinary(
+    `(module
+       (import "" "mem" (memory 1))
+       (data (i32.const 65534) "\\01\\02\\03") ;; fails after 1 and 2
+       (data (i32.const 0) "\\04")             ;; is not applied
+     )`));
+var mem = new Memory({initial:1});
+assertSegmentFitError(() => new Instance(m, {"":{mem}}));
+var v = new Uint8Array(mem.buffer);
+assertEq(v[65534], 0);
+assertEq(v[65535], 0);
+assertEq(v[0], 0);
+
+// Elem segments on imported tables
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (import "a" "b" (table 10 funcref))
+        (elem (i32.const 0) $one $two)
+        (elem (i32.const 3) $three $four)
+        (func $one (result i32) (i32.const 1))
+        (func $two (result i32) (i32.const 2))
+        (func $three (result i32) (i32.const 3))
+        (func $four (result i32) (i32.const 4)))
+`));
+var tbl = new Table({initial:10, element:"anyfunc"});
+new Instance(m, {a:{b:tbl}});
+assertEq(tbl.get(0)(), 1);
+assertEq(tbl.get(1)(), 2);
+assertEq(tbl.get(2), null);
+assertEq(tbl.get(3)(), 3);
+assertEq(tbl.get(4)(), 4);
+for (var i = 5; i < 10; i++)
+    assertEq(tbl.get(i), null);
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (func $their1 (import "" "func") (result i32))
+        (func $their2 (import "" "func"))
+        (table (import "" "table") 4 funcref)
+        (func $my (result i32) i32.const 13)
+        (elem (i32.const 1) $my)
+        (elem (i32.const 2) $their1)
+        (elem (i32.const 3) $their2)
+    )
+`));
+var tbl = new Table({initial:4, element:"anyfunc"});
+var f = () => 42;
+new Instance(m, { "": { table: tbl, func: f} });
+assertEq(tbl.get(0), null);
+assertEq(tbl.get(1)(), 13);
+assertEq(tbl.get(2)(), 42);
+assertEq(tbl.get(3)(), undefined);
+
+// Cross-instance calls
+
+var i1 = new Instance(new Module(wasmTextToBinary(`(module (func) (func (param i32) (result i32) (i32.add (local.get 0) (i32.const 1))) (func) (export "f" (func 1)))`)));
+var i2 = new Instance(new Module(wasmTextToBinary(`(module (import "a" "b" (func $imp (param i32) (result i32))) (func $g (result i32) (call $imp (i32.const 13))) (export "g" (func $g)))`)), {a:{b:i1.exports.f}});
+assertEq(i2.exports.g(), 14);
+
+var i1 = new Instance(new Module(wasmTextToBinary(`(module
+    (memory 1 1)
+    (data (i32.const 0) "\\42")
+    (func $f (result i32) (i32.load (i32.const 0)))
+    (export "f" (func $f))
+)`)));
+var i2 = new Instance(new Module(wasmTextToBinary(`(module
+    (import "a" "b" (func $imp (result i32)))
+    (memory 1 1)
+    (data (i32.const 0) "\\13")
+    (table 2 2 funcref)
+    (elem (i32.const 0) $imp $def)
+    (func $def (result i32) (i32.load (i32.const 0)))
+    (type $v2i (func (result i32)))
+    (func $call (param i32) (result i32) (call_indirect (type $v2i) (local.get 0)))
+    (export "call" (func $call))
+)`)), {a:{b:i1.exports.f}});
+assertEq(i2.exports.call(0), 0x42);
+assertEq(i2.exports.call(1), 0x13);
+
+var m = new Module(wasmTextToBinary(`(module
+    (import "a" "val" (global $val i32))
+    (import "a" "next" (func $next (result i32)))
+    (memory 1)
+    (func $start (i32.store (i32.const 0) (global.get $val)))
+    (start $start)
+    (func $call (result i32)
+        (i32.add
+            (global.get $val)
+            (i32.add
+                (i32.load (i32.const 0))
+                (call $next))))
+    (export "call" (func $call))
+)`));
+var e = {call:() => 1000};
+for (var i = 0; i < 10; i++)
+    e = new Instance(m, {a:{val:i, next:e.call}}).exports;
+assertEq(e.call(), 1090);
+
+(function testImportJitExit() {
+    let options = getJitCompilerOptions();
+    if (!options['baseline.enable'])
+        return;
+
+    let baselineTrigger = options['baseline.warmup.trigger'];
+
+    let valueToConvert = 0;
+    function ffi(n) { if (n == 1337) { return valueToConvert }; return 42; }
+
+    function sum(a, b, c) {
+        if (a === 1337)
+            return valueToConvert;
+        return (a|0) + (b|0) + (c|0) | 0;
+    }
+
+    // Baseline compile ffis.
+    for (let i = baselineTrigger + 1; i --> 0;) {
+        ffi(i);
+        sum((i%2)?i:undefined,
+            (i%3)?i:undefined,
+            (i%4)?i:undefined);
+    }
+
+    let imports = {
+        a: {
+            ffi,
+            sum
+        }
+    };
+
+    i = wasmEvalText(`(module
+        (import "a" "ffi" (func $ffi (param i32) (result i32)))
+
+        (import "a" "sum" (func $missingOneArg (param i32) (param i32) (result i32)))
+        (import "a" "sum" (func $missingTwoArgs (param i32) (result i32)))
+        (import "a" "sum" (func $missingThreeArgs (result i32)))
+
+        (func (export "foo") (param i32) (result i32)
+         local.get 0
+         call $ffi
+        )
+
+        (func (export "missThree") (result i32)
+         call $missingThreeArgs
+        )
+
+        (func (export "missTwo") (param i32) (result i32)
+         local.get 0
+         call $missingTwoArgs
+        )
+
+        (func (export "missOne") (param i32) (param i32) (result i32)
+         local.get 0
+         local.get 1
+         call $missingOneArg
+        )
+    )`, imports).exports;
+
+    // Enable the jit exit for each JS callee.
+    assertEq(i.foo(0), 42);
+
+    assertEq(i.missThree(), 0);
+    assertEq(i.missTwo(42), 42);
+    assertEq(i.missOne(13, 37), 50);
+
+    // Test the jit exit under normal conditions.
+    assertEq(i.foo(0), 42);
+    assertEq(i.foo(1337), 0);
+
+    // Test the arguments rectifier.
+    assertEq(i.missThree(), 0);
+    assertEq(i.missTwo(-1), -1);
+    assertEq(i.missOne(23, 10), 33);
+
+    // Test OOL coercion.
+    valueToConvert = 2**31;
+    assertEq(i.foo(1337), -(2**31));
+
+    // Test OOL error path.
+    valueToConvert = { valueOf() { throw new Error('make ffi great again'); } }
+    assertErrorMessage(() => i.foo(1337), Error, "make ffi great again");
+
+    valueToConvert = { toString() { throw new Error('a FFI to believe in'); } }
+    assertErrorMessage(() => i.foo(1337), Error, "a FFI to believe in");
+
+    // Test the error path in the arguments rectifier.
+    assertErrorMessage(() => i.missTwo(1337), Error, "a FFI to believe in");
+})();
+
+(function testCrossRealmImport() {
+    var g = newGlobal({sameCompartmentAs: this});
+    g.evaluate("function f1() { assertCorrectRealm(); return 123; }");
+    g.mem = new Memory({initial:8});
+
+    // The memory.size builtin asserts cx->realm matches instance->realm so
+    // we call it here.
+    var i1 = new Instance(new Module(wasmTextToBinary(`
+        (module
+            (import "a" "f1" (func $imp1 (result i32)))
+            (import "a" "f2" (func $imp2 (result i32)))
+            (import "a" "m" (memory 1))
+            (func $test (result i32)
+                (i32.add
+                    (i32.add
+                        (i32.add (memory.size) (call $imp1))
+                        (memory.size))
+                    (call $imp2)))
+            (export "impstub" (func $imp1))
+            (export "test" (func $test)))
+    `)), {a:{m:g.mem, f1:g.f1, f2:g.Math.abs}});
+
+    for (var i = 0; i < 20; i++) {
+        assertEq(i1.exports.impstub(), 123);
+        assertEq(i1.exports.test(), 139);
+    }
+
+    // Inter-module/inter-realm wasm => wasm calls.
+    var src = `
+        (module
+            (import "a" "othertest" (func $imp (result i32)))
+            (import "a" "m" (memory 1))
+            (func (result i32) (i32.add (call $imp) (memory.size)))
+            (export "test" (func 1)))
+    `;
+    g.i1 = i1;
+    g.evaluate("i2 = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`" + src + "`)), {a:{m:mem,othertest:i1.exports.test}})");
+    for (var i = 0; i < 20; i++)
+        assertEq(g.i2.exports.test(), 147);
+})();
+
+// The name presented in toString and as the fn.name property is the index of the
+// function within the module.  See bug 1714505 for analysis.
+
+var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (export "myfunc") (result i32)
+    (i32.const 1337))
+  (func $hi (result i32)
+    (i32.const 3))
+  (func $abracadabra (export "bletch") (result i32)
+    (i32.const -1)))`)))
+assertEq(String(ins.exports.myfunc), "function 0() {\n    [native code]\n}")
+assertEq(ins.exports.myfunc.name, "0");
+assertEq(String(ins.exports.bletch), "function 2() {\n    [native code]\n}")
+assertEq(ins.exports.bletch.name, "2")
diff --git a/js/src/jit-test/tests/wasm/import-gc.js b/js/src/jit-test/tests/wasm/import-gc.js
new file mode 100644
index 0000000000..02caea73d9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/import-gc.js
@@ -0,0 +1,62 @@
+// |jit-test| --no-baseline; --no-blinterp
+// Turn off baseline and since it messes up the GC finalization assertions by
+// adding spurious edges to the GC graph.
+
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+
+const m1 = new Module(wasmTextToBinary(`(module (func $f) (export "f" (func $f)))`));
+const m2 = new Module(wasmTextToBinary(`(module (import "a" "f" (func)) (func $f) (export "g" (func $f)))`));
+
+// Imported instance objects should stay alive as long as any importer is alive.
+resetFinalizeCount();
+var i1 = new Instance(m1);
+var i2 = new Instance(m2, {a:i1.exports});
+var f = i1.exports.f;
+var g = i2.exports.g;
+i1.edge = makeFinalizeObserver();
+i2.edge = makeFinalizeObserver();
+f.edge = makeFinalizeObserver();
+g.edge = makeFinalizeObserver();
+gc();
+assertEq(finalizeCount(), 0);
+i1.exports = null;
+f = null;
+gc();
+assertEq(finalizeCount(), 0);
+i2 = null;
+gc();
+assertEq(finalizeCount(), 0);
+i1 = null;
+gc();
+assertEq(finalizeCount(), 0);
+g = null;
+gc();
+assertEq(finalizeCount(), 4);
+
+// ...but the importee doesn't keep the importer alive.
+resetFinalizeCount();
+var i1 = new Instance(m1);
+var i2 = new Instance(m2, {a:i1.exports});
+var f = i1.exports.f;
+var g = i2.exports.g;
+i1.edge = makeFinalizeObserver();
+i2.edge = makeFinalizeObserver();
+f.edge = makeFinalizeObserver();
+g.edge = makeFinalizeObserver();
+gc();
+assertEq(finalizeCount(), 0);
+i2.exports = null;
+g = null;
+gc();
+assertEq(finalizeCount(), 0);
+i2 = null;
+gc();
+assertEq(finalizeCount(), 2);
+i1.exports = null;
+f = null;
+gc();
+assertEq(finalizeCount(), 2);
+i1 = null;
+gc();
+assertEq(finalizeCount(), 4);
diff --git a/js/src/jit-test/tests/wasm/integer.js b/js/src/jit-test/tests/wasm/integer.js
new file mode 100644
index 0000000000..f7839a0ccf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/integer.js
@@ -0,0 +1,397 @@
+assertEq(wasmEvalText('(module (func (result i32) (i32.const -1)) (export "" (func 0)))').exports[""](), -1);
+assertEq(wasmEvalText('(module (func (result i32) (i32.const -2147483648)) (export "" (func 0)))').exports[""](), -2147483648);
+assertEq(wasmEvalText('(module (func (result i32) (i32.const 4294967295)) (export "" (func 0)))').exports[""](), -1);
+
+function testUnary(type, opcode, op, expect) {
+    if (type === 'i64') {
+        // Test with constant
+        wasmFullPassI64(`(module (func $run (result ${type}) (${type}.${opcode} (${type}.const ${op}))))`, expect);
+        // Test with param
+        wasmFullPassI64(`(module (func $run (param ${type}) (result ${type}) (${type}.${opcode} (local.get 0))))`, expect, {}, `i64.const ${op}`);
+        return;
+    }
+    // Test with constant
+    wasmFullPass(`(module (func (result ${type}) (${type}.${opcode} (${type}.const ${op}))) (export "run" (func 0)))`, expect);
+    // Test with param
+    wasmFullPass(`(module (func (param ${type}) (result ${type}) (${type}.${opcode} (local.get 0))) (export "run" (func 0)))`, expect, {}, op);
+}
+
+function testBinary64(opcode, lhs, rhs, expect) {
+    let lsrc = `i64.const ${lhs}`;
+    let rsrc = `i64.const ${rhs}`;
+    wasmFullPassI64(`(module (func $run (param i64) (param i64) (result i64) (i64.${opcode} (local.get 0) (local.get 1))))`, expect, {}, lsrc, rsrc);
+    // The same, but now the RHS is a constant.
+    wasmFullPassI64(`(module (func $run (param i64) (result i64) (i64.${opcode} (local.get 0) (i64.const ${rhs}))))`, expect, {}, lsrc);
+    // LHS and RHS are constants.
+    wasmFullPassI64(`(module (func $run (result i64) (i64.${opcode} (i64.const ${lhs}) (i64.const ${rhs}))))`, expect);
+}
+
+function testBinary32(opcode, lhs, rhs, expect) {
+    wasmFullPass(`(module (func (param i32) (param i32) (result i32) (i32.${opcode} (local.get 0) (local.get 1))) (export "run" (func 0)))`, expect, {}, lhs, rhs);
+    // The same, but now the RHS is a constant.
+    wasmFullPass(`(module (func (param i32) (result i32) (i32.${opcode} (local.get 0) (i32.const ${rhs}))) (export "run" (func 0)))`, expect, {}, lhs);
+    // LHS and RHS are constants.
+    wasmFullPass(`(module (func (result i32) (i32.${opcode} (i32.const ${lhs}) (i32.const ${rhs}))) (export "run" (func 0)))`, expect);
+}
+
+function testComparison32(opcode, lhs, rhs, expect) {
+    wasmFullPass(`(module (func (param i32) (param i32) (result i32) (i32.${opcode} (local.get 0) (local.get 1))) (export "run" (func 0)))`, expect, {}, lhs, rhs);
+}
+function testComparison64(opcode, lhs, rhs, expect) {
+    let lsrc = `i64.const ${lhs}`;
+    let rsrc = `i64.const ${rhs}`;
+
+    wasmFullPass(`(module
+                    (func $cmp (param i64) (param i64) (result i32) (i64.${opcode} (local.get 0) (local.get 1)))
+                    (func $assert (result i32)
+                     i64.const ${lhs}
+                     i64.const ${rhs}
+                     call $cmp
+                    )
+                    (export "run" (func $assert)))`, expect);
+
+    // Also test `if`, for the compare-and-branch path.
+    wasmFullPass(`(module
+                    (func $cmp (param i64) (param i64) (result i32)
+                      (if (result i32) (i64.${opcode} (local.get 0) (local.get 1))
+                       (i32.const 1)
+                       (i32.const 0)))
+                    (func $assert (result i32)
+                     i64.const ${lhs}
+                     i64.const ${rhs}
+                     call $cmp
+                    )
+                    (export "run" (func $assert)))`, expect);
+}
+
+function testI64Eqz(input, expect) {
+    wasmFullPass(`(module (func (result i32) (i64.eqz (i64.const ${input}))) (export "run" (func 0)))`, expect, {});
+    wasmFullPass(`(module
+        (func (param i64) (result i32) (i64.eqz (local.get 0)))
+        (func $assert (result i32) (i64.const ${input}) (call 0))
+        (export "run" (func $assert)))`, expect);
+}
+
+function testTrap32(opcode, lhs, rhs, expect) {
+    assertErrorMessage(() => wasmEvalText(`(module (func (param i32) (param i32) (result i32) (i32.${opcode} (local.get 0) (local.get 1))) (export "" (func 0)))`).exports[""](lhs, rhs), Error, expect);
+    // The same, but now the RHS is a constant.
+    assertErrorMessage(() => wasmEvalText(`(module (func (param i32) (result i32) (i32.${opcode} (local.get 0) (i32.const ${rhs}))) (export "" (func 0)))`).exports[""](lhs), Error, expect);
+    // LHS and RHS are constants.
+    assertErrorMessage(wasmEvalText(`(module (func (result i32) (i32.${opcode} (i32.const ${lhs}) (i32.const ${rhs}))) (export "" (func 0)))`).exports[""], Error, expect);
+}
+
+function testTrap64(opcode, lhs, rhs, expect) {
+    let $call = ``;
+
+    assertErrorMessage(wasmEvalText(`(module
+        (func (param i64) (param i64) (result i64) (i64.${opcode} (local.get 0) (local.get 1)))
+        (func $f (export "") (i64.const ${lhs}) (i64.const ${rhs}) (call 0) drop)
+    )`).exports[""], Error, expect);
+    // The same, but now the RHS is a constant.
+    assertErrorMessage(wasmEvalText(`(module
+        (func (param i64) (result i64) (i64.${opcode} (local.get 0) (i64.const ${rhs})))
+        (func $f (export "") (i64.const ${lhs}) (call 0) drop)
+    )`).exports[""], Error, expect);
+    // LHS and RHS are constants.
+    assertErrorMessage(wasmEvalText(`(module
+        (func (result i64) (i64.${opcode} (i64.const ${lhs}) (i64.const ${rhs})))
+        (func $f (export "") (call 0) drop)
+    )`).exports[""], Error, expect);
+}
+
+testUnary('i32', 'clz', 40, 26);
+testUnary('i32', 'clz', 0, 32);
+testUnary('i32', 'clz', 0xFFFFFFFF, 0);
+testUnary('i32', 'clz', -2147483648, 0);
+
+testUnary('i32', 'ctz', 40, 3);
+testUnary('i32', 'ctz', 0, 32);
+testUnary('i32', 'ctz', -2147483648, 31);
+
+testUnary('i32', 'popcnt', 40, 2);
+testUnary('i32', 'popcnt', 0, 0);
+testUnary('i32', 'popcnt', 0xFFFFFFFF, 32);
+
+testUnary('i32', 'eqz', 0, 1);
+testUnary('i32', 'eqz', 1, 0);
+testUnary('i32', 'eqz', 0xFFFFFFFF, 0);
+
+testBinary32('add', 40, 2, 42);
+testBinary32('sub', 40, 2, 38);
+testBinary32('mul', 40, 2, 80);
+testBinary32('div_s', -40, 2, -20);
+testBinary32('div_s', -40, 8, -5);
+testBinary32('div_s', -40, 7, -5);
+testBinary32('div_s', 40, 8, 5);
+testBinary32('div_s', 40, 7, 5);
+testBinary32('div_u', -40, 2, 2147483628);
+testBinary32('div_u', 40, 2, 20);
+testBinary32('div_u', 40, 8, 5);
+testBinary32('rem_s', 40, -3, 1);
+testBinary32('rem_s', 0, -3, 0);
+testBinary32('rem_s', 5, 2, 1);
+testBinary32('rem_s', 65, 64, 1);
+testBinary32('rem_s', -65, 64, -1);
+testBinary32('rem_u', 40, -3, 40);
+testBinary32('rem_u', 41, 8, 1);
+testBinary32('and', 42, 6, 2);
+testBinary32('or', 42, 6, 46);
+testBinary32('xor', 42, 2, 40);
+testBinary32('xor', -1, 1739168047, -1739168048);
+testBinary32('xor', -1739168043, -1, 1739168042);
+testBinary32('shl', 40, 0, 40);
+testBinary32('shl', 40, 2, 160);
+testBinary32('shr_s', -40, 0, -40);
+testBinary32('shr_s', -40, 2, -10);
+testBinary32('shr_u', -40, 0, -40);
+testBinary32('shr_u', -40, 2, 1073741814);
+
+testTrap32('div_s', 42, 0, /integer divide by zero/);
+testTrap32('div_s', 0x80000000 | 0, -1, /integer overflow/);
+testTrap32('div_u', 42, 0, /integer divide by zero/);
+testTrap32('rem_s', 42, 0, /integer divide by zero/);
+testTrap32('rem_u', 42, 0, /integer divide by zero/);
+
+testBinary32('rotl', 40, 2, 160);
+testBinary32('rotl', 40, 34, 160);
+testBinary32('rotr', 40, 2, 10);
+testBinary32('rotr', 40, 34, 10);
+testBinary32('rotr', 40, 0, 40);
+testBinary32('rotl', 40, 0, 40);
+
+testComparison32('eq', 40, 40, 1);
+testComparison32('ne', 40, 40, 0);
+testComparison32('lt_s', 40, 40, 0);
+testComparison32('lt_u', 40, 40, 0);
+testComparison32('le_s', 40, 40, 1);
+testComparison32('le_u', 40, 40, 1);
+testComparison32('gt_s', 40, 40, 0);
+testComparison32('gt_u', 40, 40, 0);
+testComparison32('ge_s', 40, 40, 1);
+testComparison32('ge_u', 40, 40, 1);
+
+// On 32-bit debug builds, with --ion-eager, this test can run into our
+// per-process JIT code limits and OOM. Trigger a GC to discard code.
+if (getJitCompilerOptions()["ion.warmup.trigger"] === 0)
+    gc();
+
+// Test MTest's GVN branch inversion.
+var testTrunc = wasmEvalText(`(module (func (param f32) (result i32) (if (result i32) (i32.eqz (i32.trunc_s/f32 (local.get 0))) (i32.const 0) (i32.const 1))) (export "" (func 0)))`).exports[""];
+assertEq(testTrunc(0), 0);
+assertEq(testTrunc(13.37), 1);
+
+testBinary64('add', 40, 2, 42);
+testBinary64('add', "0x1234567887654321", -1, "0x1234567887654320");
+testBinary64('add', "0xffffffffffffffff", 1, 0);
+testBinary64('sub', 40, 2, 38);
+testBinary64('sub', "0x1234567887654321", "0x123456789", "0x12345677641fdb98");
+testBinary64('sub', 3, 5, -2);
+testBinary64('mul', 40, 2, 80);
+testBinary64('mul', -1, 2, -2);
+testBinary64('mul', 0x123456, "0x9876543210", "0xad77d2c5f941160");
+testBinary64('mul', 2, -1, -2);
+testBinary64('mul', "0x80000000", -1, -2147483648);
+testBinary64('mul', "0x7fffffff", -1, -2147483647);
+testBinary64('mul', "0x7fffffffffffffff", -1, "0x8000000000000001");
+testBinary64('mul', 2, 2, 4);
+testBinary64('mul', "0x80000000", 2, "0x100000000");
+testBinary64('mul', "0x7fffffff", 2, "0xfffffffe");
+testBinary64('div_s', -40, 2, -20);
+testBinary64('div_s', -40, 8, -5);
+testBinary64('div_s', -40, 7, -5);
+testBinary64('div_s', 40, 8, 5);
+testBinary64('div_s', 40, 7, 5);
+testBinary64('div_s', "0x1234567887654321", 2, "0x91a2b3c43b2a190");
+testBinary64('div_s', "0x1234567887654321", "0x1000000000", "0x1234567");
+testBinary64('div_s', -1, "0x100000000", 0);
+testBinary64('div_u', -40, 2, "0x7fffffffffffffec");
+testBinary64('div_u', "0x1234567887654321", 9, "0x205d0b80f0b4059");
+testBinary64('div_u', 40, 2, 20);
+testBinary64('div_u', 40, 8, 5);
+testBinary64('rem_s', 40, -3, 1);
+testBinary64('rem_s', 0, -3, 0);
+testBinary64('rem_s', 5, 2, 1);
+testBinary64('rem_s', 65, 64, 1);
+testBinary64('rem_s', "0x1234567887654321", "0x1000000000", "0x887654321");
+testBinary64('rem_s', "0x7fffffffffffffff", -1, 0);
+testBinary64('rem_s', "0x8000000000000001", 1000, -807);
+testBinary64('rem_s', "0x8000000000000000", -1, 0);
+testBinary64('rem_u', 40, -3, 40);
+testBinary64('rem_u', 41, 8, 1);
+testBinary64('rem_u', "0x1234567887654321", "0x1000000000", "0x887654321");
+testBinary64('rem_u', "0x8000000000000000", -1, "0x8000000000000000");
+testBinary64('rem_u', "0x8ff00ff00ff00ff0", "0x100000001", "0x80000001");
+
+testTrap64('div_s', 10, 0, /integer divide by zero/);
+testTrap64('div_s', "0x8000000000000000", -1, /integer overflow/);
+testTrap64('div_u', 0, 0, /integer divide by zero/);
+testTrap64('rem_s', 10, 0, /integer divide by zero/);
+testTrap64('rem_u', 10, 0, /integer divide by zero/);
+
+// Bitops.
+testBinary64('or', 42, 6, 46);
+testBinary64('or', "0x8765432112345678", "0xffff0000ffff0000", "0xffff4321ffff5678");
+
+testBinary64('xor', 42, 2, 40);
+testBinary64('xor', "0x8765432112345678", "0xffff0000ffff0000", "0x789a4321edcb5678");
+testBinary64('xor', "0xffffffffffffffff", "0x2c73173d985666d0", "0xd38ce8c267a9992f");
+testBinary64('xor', "0xe8f3437fe059746a", "0xffffffffffffffff", "0x170cbc801fa68b95");
+
+testBinary64('shl', 0xff00ff, 28, "0x0ff00ff0000000");
+testBinary64('shl', 0xff00ff, 30, "0x3fc03fc0000000");
+testBinary64('shl', 0xff00ff, 31, "0x7f807f80000000");
+testBinary64('shl', 0xff00ff, 32, "0xff00ff00000000");
+testBinary64('shl', 1, 63, "0x8000000000000000");
+testBinary64('shl', 1, 64, 1);
+testBinary64('shl', 40, 2, 160);
+testBinary64('shl', 40, 0, 40);
+
+testBinary64('shr_s', -40, 0, -40);
+testBinary64('shr_s', -40, 2, -10);
+testBinary64('shr_s', "0xff00ff0000000", 28, 0xff00ff);
+testBinary64('shr_s', "0xff00ff0000000", 30, 0x3fc03f);
+testBinary64('shr_s', "0xff00ff0000000", 31, 0x1fe01f);
+testBinary64('shr_s', "0xff00ff0000000", 32, 0x0ff00f);
+
+testBinary64('shr_u', -40, 0, -40);
+testBinary64('shr_u', -40, 2, "0x3ffffffffffffff6");
+testBinary64('shr_u', "0x8ffff00ff0000000", 30, "0x23fffc03f");
+testBinary64('shr_u', "0x8ffff00ff0000000", 31, "0x11fffe01f");
+testBinary64('shr_u', "0x8ffff00ff0000000", 32, "0x08ffff00f");
+testBinary64('shr_u', "0x8ffff00ff0000000", 56, 0x8f);
+
+testBinary64('and', 42, 0, 0);
+testBinary64('and', 42, 6, 2);
+testBinary64('and', "0x0000000012345678", "0xffff0000ffff0000", "0x0000000012340000");
+testBinary64('and', "0x8765432112345678", "0xffff0000ffff0000", "0x8765000012340000");
+
+// Rotations.
+testBinary64('rotl', 40, 0, 0x28);
+testBinary64('rotl', 40, 2, 0xA0);
+testBinary64('rotl', 40, 8, 0x2800);
+testBinary64('rotl', 40, 30, "0xA00000000");
+testBinary64('rotl', 40, 31, "0x1400000000");
+testBinary64('rotl', 40, 32, "0x2800000000");
+
+testBinary64('rotl', "0x1234567812345678", 4, "0x2345678123456781");
+testBinary64('rotl', "0x1234567812345678", 30, "0x048D159E048D159E");
+testBinary64('rotl', "0x1234567812345678", 31, "0x091A2B3C091A2B3C");
+testBinary64('rotl', "0x1234567812345678", 32, "0x1234567812345678");
+
+testBinary64('rotl', "0x0000000000001000", 127, "0x0000000000000800");
+
+testBinary64('rotr', 40, 0, 0x28);
+testBinary64('rotr', 40, 2, 0x0A);
+testBinary64('rotr', 40, 30, "0xA000000000");
+testBinary64('rotr', 40, 31, "0x5000000000");
+testBinary64('rotr', 40, 32, "0x2800000000");
+
+testBinary64('rotr', "0x1234567812345678", 4, "0x8123456781234567");
+testBinary64('rotr', "0x1234567812345678", 30, "0x48D159E048D159E0");
+testBinary64('rotr', "0x1234567812345678", 31, "0x2468ACF02468ACF0");
+testBinary64('rotr', "0x1234567812345678", 32, "0x1234567812345678");
+testBinary64('rotr', "0x1234567812345678", 60, "0x2345678123456781");
+
+testBinary64('rotr', "0x0000000000001000", 127, "0x0000000000002000");
+
+// Comparisons.
+testComparison64('eq', 40, 40, 1);
+testComparison64('ne', 40, 40, 0);
+testComparison64('lt_s', 40, 40, 0);
+testComparison64('lt_u', 40, 40, 0);
+testComparison64('le_s', 40, 40, 1);
+testComparison64('le_u', 40, 40, 1);
+testComparison64('gt_s', 40, 40, 0);
+testComparison64('gt_u', 40, 40, 0);
+testComparison64('ge_s', 40, 40, 1);
+testComparison64('ge_u', 40, 40, 1);
+testComparison64('eq', "0x400012345678", "0x400012345678", 1);
+testComparison64('eq', "0x400012345678", "0x500012345678", 0);
+testComparison64('ne', "0x400012345678", "0x400012345678", 0);
+testComparison64('ne', "0x400012345678", "0x500012345678", 1);
+testComparison64('eq', "0xffffffffffffffff", -1, 1);
+testComparison64('lt_s', "0x8000000012345678", "0x1", 1);
+testComparison64('lt_s', "0x1", "0x8000000012345678", 0);
+testComparison64('lt_u', "0x8000000012345678", "0x1", 0);
+testComparison64('lt_u', "0x1", "0x8000000012345678", 1);
+testComparison64('le_s', -1, 0, 1);
+testComparison64('le_s', -1, -1, 1);
+testComparison64('le_s', 0, -1, 0);
+testComparison64('le_u', -1, 0, 0);
+testComparison64('le_u', -1, -1, 1);
+testComparison64('le_u', 0, -1, 1);
+testComparison64('gt_s', 1, "0x8000000000000000", 1);
+testComparison64('gt_s', "0x8000000000000000", 1, 0);
+testComparison64('gt_u', 1, "0x8000000000000000", 0);
+testComparison64('gt_u', "0x8000000000000000", 1, 1);
+testComparison64('ge_s', 1, "0x8000000000000000", 1);
+testComparison64('ge_s', "0x8000000000000000", 1, 0);
+testComparison64('ge_u', 1, "0x8000000000000000", 0);
+testComparison64('ge_u', "0x8000000000000000", 1, 1);
+
+testUnary('i64', 'clz', 40, 58);
+testUnary('i64', 'clz', "0x8000000000000000", 0);
+testUnary('i64', 'clz', "0x7fffffffffffffff", 1);
+testUnary('i64', 'clz', "0x4000000000000000", 1);
+testUnary('i64', 'clz', "0x3000000000000000", 2);
+testUnary('i64', 'clz', "0x2000000000000000", 2);
+testUnary('i64', 'clz', "0x1000000000000000", 3);
+testUnary('i64', 'clz', "0x0030000000000000", 10);
+testUnary('i64', 'clz', "0x0000800000000000", 16);
+testUnary('i64', 'clz', "0x00000000ffffffff", 32);
+testUnary('i64', 'clz', -1, 0);
+testUnary('i64', 'clz', 0, 64);
+
+testUnary('i64', 'ctz', 40, 3);
+testUnary('i64', 'ctz', "0x8000000000000000", 63);
+testUnary('i64', 'ctz', "0x7fffffffffffffff", 0);
+testUnary('i64', 'ctz', "0x4000000000000000", 62);
+testUnary('i64', 'ctz', "0x3000000000000000", 60);
+testUnary('i64', 'ctz', "0x2000000000000000", 61);
+testUnary('i64', 'ctz', "0x1000000000000000", 60);
+testUnary('i64', 'ctz', "0x0030000000000000", 52);
+testUnary('i64', 'ctz', "0x0000800000000000", 47);
+testUnary('i64', 'ctz', "0x00000000ffffffff", 0);
+testUnary('i64', 'ctz', -1, 0);
+testUnary('i64', 'ctz', 0, 64);
+
+testUnary('i64', 'popcnt', 40, 2);
+testUnary('i64', 'popcnt', 0, 0);
+testUnary('i64', 'popcnt', "0x8000000000000000", 1);
+testUnary('i64', 'popcnt', "0x7fffffffffffffff", 63);
+testUnary('i64', 'popcnt', "0x4000000000000000", 1);
+testUnary('i64', 'popcnt', "0x3000000000000000", 2);
+testUnary('i64', 'popcnt', "0x2000000000000000", 1);
+testUnary('i64', 'popcnt', "0x1000000000000000", 1);
+testUnary('i64', 'popcnt', "0x0030000000000000", 2);
+testUnary('i64', 'popcnt', "0x0000800000000000", 1);
+testUnary('i64', 'popcnt', "0x00000000ffffffff", 32);
+testUnary('i64', 'popcnt', -1, 64);
+testUnary('i64', 'popcnt', 0, 0);
+
+testI64Eqz(40, 0);
+testI64Eqz(0, 1);
+
+wasmAssert(`(module (func $run (param i64) (result i64) (local i64) (local.set 1 (i64.shl (local.get 0) (local.get 0))) (i64.shl (local.get 1) (local.get 1))))`,
+           [{ type: 'i64', func: '$run', args: ['i64.const 2'], expected: 2048}]);
+
+// Test MTest's GVN branch inversion.
+var testTrunc = wasmEvalText(`(module (func (param f32) (result i32) (if (result i32) (i64.eqz (i64.trunc_s/f32 (local.get 0))) (i32.const 0) (i32.const 1))) (export "" (func 0)))`).exports[""];
+assertEq(testTrunc(0), 0);
+assertEq(testTrunc(13.37), 1);
+
+wasmAssert(`(module (func $run (result i64) (local i64) (local.set 0 (i64.rem_s (i64.const 1) (i64.const 0xf))) (i64.rem_s (local.get 0) (local.get 0))))`,
+           [{ type: 'i64', func: '$run', expected: 0 }]);
+
+wasmFailValidateText('(module (func (param f32) (result i32) (i32.clz (local.get 0))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (result f32) (i32.clz (local.get 0))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (result f32) (i32.clz (local.get 0))))', mismatchError("f32", "i32"));
+
+wasmFailValidateText('(module (func (param f32) (param i32) (result i32) (i32.add (local.get 0) (local.get 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (param f32) (result i32) (i32.add (local.get 0) (local.get 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (param i32) (result f32) (i32.add (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
+wasmFailValidateText('(module (func (param f32) (param f32) (result f32) (i32.add (local.get 0) (local.get 1))))', mismatchError("f32", "i32"));
+
+wasmFailValidateText('(module (func (param f32) (param i32) (result i32) (i32.eq (local.get 0) (local.get 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (param f32) (result i32) (i32.eq (local.get 0) (local.get 1))))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func (param i32) (param i32) (result f32) (i32.eq (local.get 0) (local.get 1))))', mismatchError("i32", "f32"));
diff --git a/js/src/jit-test/tests/wasm/intrinsics/directives.txt b/js/src/jit-test/tests/wasm/intrinsics/directives.txt
new file mode 100644
index 0000000000..87d59ea13c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/intrinsics/i8vecmul.js b/js/src/jit-test/tests/wasm/intrinsics/i8vecmul.js
new file mode 100644
index 0000000000..22bbb169d9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/i8vecmul.js
@@ -0,0 +1,32 @@
+let memory = new WebAssembly.Memory({initial: 1});
+let bytes = new Uint8Array(memory.buffer);
+
+let module = wasmIntrinsicI8VecMul();
+let instance = new WebAssembly.Instance(module, {
+  "": {"memory": memory}
+});
+let {i8vecmul} = instance.exports;
+
+// Test basic vector pairwise product
+{
+  // [0, 1, 2, 3] . [0, 2, 4, 6] = [0, 2, 8, 18]
+  for (let i = 0; i < 4; i++) {
+    bytes[i] = i;
+    bytes[4 + i] = i * 2;
+  }
+  i8vecmul(
+    /* dest */ 8,
+    /* src1 */ 0,
+    /* src2 */ 4,
+    /* len */ 4);
+  for (let i = 0; i < 4; i++) {
+    assertEq(bytes[8 + i], i * i * 2);
+  }
+}
+
+// Test bounds checking
+{
+  assertErrorMessage(() => i8vecmul(PageSizeInBytes - 1, 0, 0, 2), WebAssembly.RuntimeError, /index out of bounds/);
+  assertErrorMessage(() => i8vecmul(0, PageSizeInBytes - 1, 0, 2), WebAssembly.RuntimeError, /index out of bounds/);
+  assertErrorMessage(() => i8vecmul(0, 0, PageSizeInBytes - 1, 2), WebAssembly.RuntimeError, /index out of bounds/);
+}
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/CommonTestSetup.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/CommonTestSetup.js
new file mode 100644
index 0000000000..0b3455ba96
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/CommonTestSetup.js
@@ -0,0 +1,27 @@
+// |jit-test| skip-if:true;
+
+// This file contains all the code that is common to all integer gemm intrinsics' test scripts.
+
+// The test setup as string that is common to all integer gemm tests
+export const COMMON_TEST_SETUP_AS_STRING = `
+const libdir=${JSON.stringify(libdir)}; load(libdir + "wasm.js");
+let memory = new WebAssembly.Memory({initial: 1, maximum: 1});
+let module = WebAssembly.mozIntGemm();
+if (!module) {
+  throw new Error();
+}
+let instance = new WebAssembly.Instance(module, {"": {"memory": memory}});
+
+const ARRAY_ALIGNMENT = 64;
+const ROWS_A_MULTIPLIER = 1;
+const COLUMNS_A_MULTIPLIER = 64;
+const ROWS_B_MULTIPLIER = COLUMNS_A_MULTIPLIER;
+const COLUMNS_B_MULTIPLIER = 8;
+const SELECTED_COLUMNS_B_MULTIPLIER = 8;
+`
+
+// Run the test
+export function runTest(completeTestAsString) {
+  const testEnvironment = newGlobal({newCompartment: true, systemPrincipal: true});
+  testEnvironment.evaluate(completeTestAsString);
+}
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8MultiplyAndAddBias.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8MultiplyAndAddBias.js
new file mode 100644
index 0000000000..d988bb2541
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8MultiplyAndAddBias.js
@@ -0,0 +1,81 @@
+// This file contains all the tests for int8_multiply_and_add_bias intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_multiply_and_add_bias} = instance.exports;
+
+const VALID = {inputA: 0, scaleA: 1.0, zeroPointA: 0.0, inputB: ARRAY_ALIGNMENT << 2, scaleB: 1.0, zeroPointB: 0.0, inputBiasPrepared: ARRAY_ALIGNMENT << 4, unquantMultiplier: -2.0, rowsA: ROWS_A_MULTIPLIER, width: ROWS_B_MULTIPLIER, colsB: COLUMNS_B_MULTIPLIER, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // rowsA: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, invalidSize, VALID.width, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // width: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, invalidSize, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // width: Not an integral multiple of ROWS_B_MULTIPLIER
+  invalidSize = ROWS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, invalidSize, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // colB: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // colB: Not an integral multiple of COLUMNS_B_MULTIPLIER
+  invalidSize = COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // inputA: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_multiply_and_add_bias(invalidAlignment, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // inputB: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, invalidAlignment, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound;
+
+  // inputA: Out of Bounds
+  outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+  let rowsAForOutOfBound = ROWS_A_MULTIPLIER << 1;
+  assertErrorMessage(() => int8_multiply_and_add_bias(outOfBound, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, rowsAForOutOfBound, VALID.width, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // inputB: Out of Bounds
+  outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, outOfBound, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // inputBias: Out of Bounds
+  outOfBound = PageSizeInBytes - VALID.colsB;
+  assertErrorMessage(() => int8_multiply_and_add_bias(outOfBound, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, outOfBound, VALID.unquantMultiplier, VALID.rowsA, VALID.width, VALID.colsB, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  outOfBound = PageSizeInBytes - VALID.colsB;
+  assertErrorMessage(() => int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, VALID.colsB, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_multiply_and_add_bias(VALID.inputA, VALID.scaleA, VALID.zeroPointA, VALID.inputB, VALID.scaleB, VALID.zeroPointB, VALID.inputBiasPrepared, VALID.unquantMultiplier, VALID.rowsA, VALID.width, VALID.colsB, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareA.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareA.js
new file mode 100644
index 0000000000..a7f9f204f1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareA.js
@@ -0,0 +1,62 @@
+// This file contains all the tests for int8_prepare_a intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_prepare_a} = instance.exports;
+
+const VALID = {input: 0, scale: 1.0, zeroPoint: 0.0, rows: ROWS_A_MULTIPLIER, cols: COLUMNS_A_MULTIPLIER, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // row: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_a(VALID.input, VALID.scale, VALID.zeroPoint, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_a(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: Not an integral multiple of COLUMNS_A_MULTIPLIER
+  invalidSize = COLUMNS_A_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_a(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // input: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_a(invalidAlignment, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_a(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, invalidAlignment), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+
+  // input: Out of Bounds
+  assertErrorMessage(() => int8_prepare_a(outOfBound, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  assertErrorMessage(() => int8_prepare_a(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_prepare_a(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareB.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareB.js
new file mode 100644
index 0000000000..ca66a6af3c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareB.js
@@ -0,0 +1,66 @@
+// This file contains all the tests for int8_prepare_b intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_prepare_b} = instance.exports;
+
+const VALID = {input: 0, scale: 1.0, zeroPoint: 0.0, rows: ROWS_B_MULTIPLIER, cols: COLUMNS_B_MULTIPLIER, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // row: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // row: Not an integral multiple of ROWS_B_MULTIPLIER
+  invalidSize = ROWS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: Not an integral multiple of COLUMNS_B_MULTIPLIER
+  invalidSize = COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // input: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_b(invalidAlignment, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, invalidAlignment), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+
+  // input: Out of Bounds
+  assertErrorMessage(() => int8_prepare_b(outOfBound, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  assertErrorMessage(() => int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_prepare_b(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBFromQuantizedTransposed.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBFromQuantizedTransposed.js
new file mode 100644
index 0000000000..191d5fdda0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBFromQuantizedTransposed.js
@@ -0,0 +1,66 @@
+// This file contains all the tests for int8_prepare_b_from_quantized_transposed intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_prepare_b_from_quantized_transposed} = instance.exports;
+
+const VALID = {input: 0, rows: ROWS_B_MULTIPLIER, cols: COLUMNS_B_MULTIPLIER, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // row: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(VALID.input, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // row: Not an integral multiple of ROWS_B_MULTIPLIER
+  invalidSize = ROWS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(VALID.input, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(VALID.input, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: Not an integral multiple of COLUMNS_B_MULTIPLIER
+  invalidSize = COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(VALID.input, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // input: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(invalidAlignment, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(VALID.input, VALID.rows, VALID.cols, invalidAlignment), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+
+  // input: Out of Bounds
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(outOfBound, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  assertErrorMessage(() => int8_prepare_b_from_quantized_transposed(VALID.input, VALID.rows, VALID.cols, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_prepare_b_from_quantized_transposed(VALID.input, VALID.rows, VALID.cols, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBFromTransposed.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBFromTransposed.js
new file mode 100644
index 0000000000..e8e01f6b17
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBFromTransposed.js
@@ -0,0 +1,66 @@
+// This file contains all the tests for int8_prepare_b_from_transposed intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_prepare_b_from_transposed} = instance.exports;
+
+const VALID = {input: 0, scale: 1.0, zeroPoint: 0.0, rows: ROWS_B_MULTIPLIER, cols: COLUMNS_B_MULTIPLIER, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // row: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // row: Not an integral multiple of ROWS_B_MULTIPLIER
+  invalidSize = ROWS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, invalidSize, VALID.cols, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: Not an integral multiple of COLUMNS_B_MULTIPLIER
+  invalidSize = COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // input: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_b_from_transposed(invalidAlignment, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, invalidAlignment), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+
+  // input: Out of Bounds
+  assertErrorMessage(() => int8_prepare_b_from_transposed(outOfBound, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  assertErrorMessage(() => int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_prepare_b_from_transposed(VALID.input, VALID.scale, VALID.zeroPoint, VALID.rows, VALID.cols, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBias.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBias.js
new file mode 100644
index 0000000000..49c0d3f87a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8PrepareBias.js
@@ -0,0 +1,69 @@
+// This file contains all the tests for int8_prepare_bias intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_prepare_bias} = instance.exports;
+
+const VALID = {input: 0, scaleA: 1.0, zeroPointA: 0.0, scaleB: 1.0, zeroPointB: 0.0, rows: ROWS_B_MULTIPLIER, cols: COLUMNS_B_MULTIPLIER, inputBias: ARRAY_ALIGNMENT << 4, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // row: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, invalidSize, VALID.cols, VALID.inputBias, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // row: Not an integral multiple of ROWS_B_MULTIPLIER
+  invalidSize = ROWS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, invalidSize, VALID.cols, VALID.inputBias, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, invalidSize, VALID.inputBias, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: Not an integral multiple of COLUMNS_B_MULTIPLIER
+  invalidSize = COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, invalidSize, VALID.inputBias, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // input: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_prepare_bias(invalidAlignment, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, VALID.cols, VALID.inputBias, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound;
+
+  // input: Out of Bounds
+  outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+  assertErrorMessage(() => int8_prepare_bias(outOfBound, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, VALID.cols, VALID.inputBias, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // inputBias: Out of Bounds
+  outOfBound = PageSizeInBytes - VALID.cols;
+  assertErrorMessage(() => int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, VALID.cols, outOfBound, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  outOfBound = PageSizeInBytes - VALID.cols;
+  assertErrorMessage(() => int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, VALID.cols, VALID.inputBias, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_prepare_bias(VALID.input, VALID.scaleA, VALID.zeroPointA, VALID.scaleB, VALID.zeroPointB, VALID.rows, VALID.cols, VALID.inputBias, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8SelectColumnsOfB.js b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8SelectColumnsOfB.js
new file mode 100644
index 0000000000..7d13e18c9b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/I8SelectColumnsOfB.js
@@ -0,0 +1,77 @@
+// This file contains all the tests for int8_select_columns_of_b intrinsic. It depends
+// on the CommonTestSetup.js script which contains the common functionality
+// that is required for testing all the intrinsics.
+const COMMON_TEST_SETUP_SCRIPT = "./CommonTestSetup.js"
+
+// All tests for this intrinsic as a string
+const ALL_TESTS_AS_STRING =`
+let {int8_select_columns_of_b} = instance.exports;
+
+const VALID = {input: 0, rows: ROWS_B_MULTIPLIER, cols: COLUMNS_B_MULTIPLIER, colIndexList: ARRAY_ALIGNMENT << 3, sizeColIndexList: SELECTED_COLUMNS_B_MULTIPLIER, output: ARRAY_ALIGNMENT << 5};
+
+function testInvalidSize() {
+  let invalidSize;
+
+  // row: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, invalidSize, VALID.cols, VALID.colIndexList, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // row: Not an integral multiple of ROWS_B_MULTIPLIER
+  invalidSize = ROWS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, invalidSize, VALID.cols, VALID.colIndexList, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, VALID.rows, invalidSize, VALID.colIndexList, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // col: Not an integral multiple of COLUMNS_B_MULTIPLIER
+  invalidSize = COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, VALID.rows, invalidSize, VALID.colIndexList, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // sizeColIndexList: 0
+  invalidSize = 0;
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, VALID.rows, VALID.cols, VALID.colIndexList, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+
+  // sizeColIndexList: Not an integral multiple of SELECTED_COLUMNS_B_MULTIPLIER
+  invalidSize = SELECTED_COLUMNS_B_MULTIPLIER + 1;
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, VALID.rows, VALID.cols, VALID.colIndexList, invalidSize, VALID.output), WebAssembly.RuntimeError, /unreachable/);
+}
+
+function testInvalidAlignment() {
+  let invalidAlignment = ARRAY_ALIGNMENT + 1;
+
+  // input: Not an integral multiple of ARRAY_ALIGNMENT
+  assertErrorMessage(() => int8_select_columns_of_b(invalidAlignment, VALID.rows, VALID.cols, VALID.colIndexList, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testOutOfBounds() {
+  let outOfBound;
+
+  // input: Out of Bounds
+  outOfBound = PageSizeInBytes - ARRAY_ALIGNMENT;
+  assertErrorMessage(() => int8_select_columns_of_b(outOfBound, VALID.rows, VALID.cols, VALID.colIndexList, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // colIndexList: Out of Bounds
+  outOfBound = PageSizeInBytes - VALID.sizeColIndexList;
+  assertErrorMessage(() => int8_select_columns_of_b(outOfBound, VALID.rows, VALID.cols, outOfBound, VALID.sizeColIndexList, VALID.output), WebAssembly.RuntimeError, /index out of bounds/);
+
+  // output: Out of Bounds
+  outOfBound = PageSizeInBytes - (VALID.rows * VALID.sizeColIndexList);
+  assertErrorMessage(() => int8_select_columns_of_b(VALID.input, VALID.rows, VALID.cols, VALID.colIndexList, VALID.sizeColIndexList, outOfBound), WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+function testSuccessfulCall() {
+  // We just test that with valid arguments the intrinsic executes without any error
+  int8_select_columns_of_b(VALID.input, VALID.rows, VALID.cols, VALID.colIndexList, VALID.sizeColIndexList, VALID.output);
+}
+
+testInvalidSize();
+testInvalidAlignment();
+testOutOfBounds();
+testSuccessfulCall();
+`
+
+// Run all the tests
+import(COMMON_TEST_SETUP_SCRIPT).then((importedModule) => {
+  importedModule.runTest(importedModule.COMMON_TEST_SETUP_AS_STRING + ALL_TESTS_AS_STRING);
+});
diff --git a/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/directives.txt b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/directives.txt
new file mode 100644
index 0000000000..6414acbdac
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/integer-gemm/directives.txt
@@ -0,0 +1 @@
+|jit-test| --wasm-moz-intgemm; skip-if: (!getBuildConfiguration().x64 && !getBuildConfiguration().x86 && !getBuildConfiguration().arm64) || getBuildConfiguration().simulator || !wasmMozIntGemmEnabled()
diff --git a/js/src/jit-test/tests/wasm/intrinsics/oom-test.js b/js/src/jit-test/tests/wasm/intrinsics/oom-test.js
new file mode 100644
index 0000000000..6770f41fc3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/intrinsics/oom-test.js
@@ -0,0 +1,6 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+oomTest(() => {
+    const module = wasmIntrinsicI8VecMul();
+    WebAssembly.Module.imports(module);
+});
diff --git a/js/src/jit-test/tests/wasm/ion-adhoc-multiplatform.js b/js/src/jit-test/tests/wasm/ion-adhoc-multiplatform.js
new file mode 100644
index 0000000000..221ddf78c8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-adhoc-multiplatform.js
@@ -0,0 +1,632 @@
+// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || getBuildConfiguration().windows || (!getBuildConfiguration().x64 && !getBuildConfiguration().x86 && !getBuildConfiguration().arm64 && !getBuildConfiguration().arm); include:adhoc-multiplatform-test.js
+//
+// These tests push wasm functions through the ion pipe and specify an expected
+// disassembly output on all 4 primary targets, x64 / x86 / arm64 / arm(32).
+// Results must be provided for the first 3, but can optionally be skipped
+// for arm(32).
+//
+// Hence: disassembler is needed, compiler must be ion.
+//
+// Windows is disallowed because the argument registers are different from on
+// Linux, and matching both is both difficult and not of much value.
+
+// Tests are "end-to-end" in the sense that we don't care whether the
+// tested-for code improvement is done by MIR optimisation, or later in the
+// pipe.  Observed defects are marked with FIXMEs for future easy finding.
+
+
+// Note that identities involving AND, OR and XOR are tested by
+// binop-x64-ion-folding.js
+
+// Multiplication with magic constant on the left
+//
+//    0 * x =>  0
+//    1 * x =>  x
+//   -1 * x =>  -x
+//    2 * x =>  x + x
+//    4 * x =>  x << 2
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_zeroL") (param $p1 i32) (result i32)
+       (i32.mul (i32.const 0) (local.get $p1))))`,
+    "mul32_zeroL",
+    {x64:   // FIXME move folding to MIR level
+            // First we move edi to eax unnecessarily via ecx (bug 1752520),
+            // then we overwrite eax.  Presumably because the folding
+            // 0 * x => 0 is done at the LIR level, not the MIR level, hence
+            // the now-pointless WasmParameter node is not DCE'd away, since
+            // DCE only happens at the MIR level.  In fact all targets suffer
+            // from the latter problem, but on x86 no_prefix_x86:true
+            // hides it, and on arm32/64 the pointless move is correctly
+            // transformed by RA into a no-op.
+            `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             33 c0     xor %eax, %eax`,
+     x86:   `33 c0     xor %eax, %eax`,
+     arm64: `2a1f03e0  mov w0, wzr`,
+     arm:   `e3a00000  mov r0, #0`},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_zeroL") (param $p1 i64) (result i64)
+       (i64.mul (i64.const 0) (local.get $p1))))`,
+    "mul64_zeroL",
+    // FIXME folding happened, zero-creation insns could be improved
+    {x64:   // Same shenanigans as above.  Also, on xor, REX.W is redundant.
+            `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 33 c0  xor %rax, %rax`,
+     x86:   `33 c0     xor %eax, %eax
+             33 d2     xor %edx, %edx`,
+     arm64: `aa1f03e0  mov x0, xzr`,
+     arm:   // bizarrely inconsistent with the 32-bit case
+            `e0200000  eor r0, r0, r0
+             e0211001  eor r1, r1, r1` },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_oneL") (param $p1 i32) (result i32)
+       (i32.mul (i32.const 1) (local.get $p1))))`,
+    "mul32_oneL",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_oneL") (param $p1 i64) (result i64)
+       (i64.mul (i64.const 1) (local.get $p1))))`,
+    "mul64_oneL",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``},
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_minusOneL") (param $p1 i32) (result i32)
+       (i32.mul (i32.const -1) (local.get $p1))))`,
+    "mul32_minusOneL",
+    {x64:   `f7 d8     neg %eax`,
+     x86:   `f7 d8     neg %eax`,
+     arm64: `4b0003e0  neg w0, w0`,
+     arm:   `e2600000  rsb r0, r0, #0`},
+    {x86: {no_prefix:true}, x64: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_minusOneL") (param $p1 i64) (result i64)
+       (i64.mul (i64.const -1) (local.get $p1))))`,
+    "mul64_minusOneL",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 f7 d8  neg %rax`,
+     x86:   `f7 d8     neg %eax
+             83 d2 00  adc \\$0x00, %edx
+             f7 da     neg %edx`,
+     arm64: `cb0003e0  neg  x0, x0`,
+     arm:   `e2700000  rsbs r0, r0, #0
+             e2e11000  rsc  r1, r1, #0`},
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_twoL") (param $p1 i32) (result i32)
+       (i32.mul (i32.const 2) (local.get $p1))))`,
+    "mul32_twoL",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             03 c0     add %eax, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax
+             03 c0     add %eax, %eax`,
+     arm64: `0b000000  add w0, w0, w0`,
+     arm:   `e0900000  adds r0, r0, r0`},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_twoL") (param $p1 i64) (result i64)
+       (i64.mul (i64.const 2) (local.get $p1))))`,
+    "mul64_twoL",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 03 c0  add %rax, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax
+             03 c0     add %eax, %eax
+             13 d2     adc %edx, %edx`,
+     arm64: `8b000000  add  x0, x0, x0`,
+     arm:   `e0900000  adds r0, r0, r0
+             e0a11001  adc  r1, r1, r1`},
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_fourL") (param $p1 i32) (result i32)
+       (i32.mul (i32.const 4) (local.get $p1))))`,
+    "mul32_fourL",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             c1 e0 02  shl \\$0x02, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax
+             c1 e0 02  shl \\$0x02, %eax`,
+     arm64: `531e7400  lsl w0, w0, #2`,
+     arm:   `e1a00100  mov r0, r0, lsl #2`},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_fourL") (param $p1 i64) (result i64)
+       (i64.mul (i64.const 4) (local.get $p1))))`,
+    "mul64_fourL",
+    {x64:   `48 89 f9     mov %rdi, %rcx
+             48 89 c8     mov %rcx, %rax
+             48 c1 e0 02  shl \\$0x02, %rax`,
+     x86:   `8b 55 14     movl 0x14\\(%rbp\\), %edx
+             8b 45 10     movl 0x10\\(%rbp\\), %eax
+             0f a4 c2 02  shld \\$0x02, %eax, %edx
+             c1 e0 02     shl \\$0x02, %eax`,
+     arm64: `d37ef400     lsl x0, x0, #2`,
+     arm:   `e1a01101     mov r1, r1, lsl #2
+             e1811f20     orr r1, r1, r0, lsr #30
+             e1a00100     mov r0, r0, lsl #2`},
+    {x86: {no_prefix:true}}
+);
+
+// Multiplication with magic constant on the right
+//
+//  x * 0  =>  0
+//  x * 1  =>  x
+//  x * -1 =>  -x
+//  x * 2  =>  x + x
+//  x * 4  =>  x << 2
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_zeroR") (param $p1 i32) (result i32)
+       (i32.mul (local.get $p1) (i32.const 0))))`,
+    "mul32_zeroR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             33 c0     xor %eax, %eax`,
+     x86:   `33 c0     xor %eax, %eax`,
+     arm64: `2a1f03e0  mov w0, wzr`,
+     arm:   `e3a00000  mov r0, #0`},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_zeroR") (param $p1 i64) (result i64)
+       (i64.mul (local.get $p1) (i64.const 0))))`,
+    "mul64_zeroR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 33 c0  xor %rax, %rax`,     // REX.W is redundant
+     x86:   `33 c0     xor %eax, %eax
+             33 d2     xor %edx, %edx`,
+     arm64: `aa1f03e0  mov x0, xzr`,
+     arm:   `e0200000  eor r0, r0, r0
+             e0211001  eor r1, r1, r1` },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_oneR") (param $p1 i32) (result i32)
+       (i32.mul (local.get $p1) (i32.const 1))))`,
+    "mul32_oneR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_oneR") (param $p1 i64) (result i64)
+       (i64.mul (local.get $p1) (i64.const 1))))`,
+    "mul64_oneR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``},
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_minusOneR") (param $p1 i32) (result i32)
+       (i32.mul (local.get $p1) (i32.const -1))))`,
+    "mul32_minusOneR",
+    {x64:   `f7 d8     neg %eax`,
+     x86:   `f7 d8     neg %eax`,
+     arm64: `4b0003e0  neg w0, w0`,
+     arm:   `e2600000  rsb r0, r0, #0`},
+    {x86: {no_prefix:true}, x64: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_minusOneR") (param $p1 i64) (result i64)
+       (i64.mul (local.get $p1) (i64.const -1))))`,
+    "mul64_minusOneR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 f7 d8  neg %rax`,
+     x86:   `f7 d8     neg %eax
+             83 d2 00  adc \\$0x00, %edx
+             f7 da     neg %edx`,
+     arm64: `cb0003e0  neg  x0, x0`,
+     arm:   `e2700000  rsbs r0, r0, #0
+             e2e11000  rsc  r1, r1, #0`},
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_twoR") (param $p1 i32) (result i32)
+       (i32.mul (local.get $p1) (i32.const 2))))`,
+    "mul32_twoR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             03 c0     add %eax, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax
+             03 c0     add %eax, %eax`,
+     arm64: `0b000000  add w0, w0, w0`,
+     arm:   `e0900000  adds r0, r0, r0`},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_twoR") (param $p1 i64) (result i64)
+       (i64.mul (local.get $p1) (i64.const 2))))`,
+    "mul64_twoR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 03 c0  add %rax, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax
+             03 c0     add %eax, %eax
+             13 d2     adc %edx, %edx`,
+     arm64: `8b000000  add  x0, x0, x0`,
+     arm:   `e0900000  adds r0, r0, r0
+             e0a11001  adc  r1, r1, r1`},
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul32_fourR") (param $p1 i32) (result i32)
+       (i32.mul (local.get $p1) (i32.const 4))))`,
+    "mul32_fourR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             c1 e0 02  shl \\$0x02, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax
+             c1 e0 02  shl \\$0x02, %eax`,
+     arm64: `531e7400  lsl w0, w0, #2`,
+     arm:   `e1a00100  mov r0, r0, lsl #2`},
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "mul64_fourR") (param $p1 i64) (result i64)
+       (i64.mul (local.get $p1) (i64.const 4))))`,
+    "mul64_fourR",
+    {x64:   `48 89 f9     mov %rdi, %rcx
+             48 89 c8     mov %rcx, %rax
+             48 c1 e0 02  shl \\$0x02, %rax`,
+     x86:   `8b 55 14     movl 0x14\\(%rbp\\), %edx
+             8b 45 10     movl 0x10\\(%rbp\\), %eax
+             0f a4 c2 02  shld \\$0x02, %eax, %edx
+             c1 e0 02     shl \\$0x02, %eax`,
+     arm64: `d37ef400     lsl x0, x0, #2`,
+     arm:   `e1a01101     mov r1, r1, lsl #2
+             e1811f20     orr r1, r1, r0, lsr #30
+             e1a00100     mov r0, r0, lsl #2`
+    },
+    {x86: {no_prefix:true}}
+);
+
+// Shifts by zero (the right arg is zero)
+//
+// x >> 0  =>  x  (any shift kind: shl, shrU, shrS)
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "shl32_zeroR") (param $p1 i32) (result i32)
+       (i32.shl (local.get $p1) (i32.const 0))))`,
+    "shl32_zeroR",
+    // FIXME check these are consistently folded out at the MIR level
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: // Regalloc badness, plus not folded out at the MIR level
+            `2a0003e2  mov w2, w0
+             2a0203e1  mov w1, w2
+             53007c20  lsr w0, w1, #0`, // Uhh.  lsr ?!
+     arm:   `e1a02000  mov r2, r0
+             e1a01002  mov r1, r2
+             e1a00001  mov r0, r1`
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "shl64_zeroR") (param $p1 i64) (result i64)
+       (i64.shl (local.get $p1) (i64.const 0))))`,
+    "shl64_zeroR",
+    // FIXME why is this code so much better than the 32-bit case?
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``, // no-op
+     arm:   ``  // no-op
+    },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "shrU32_zeroR") (param $p1 i32) (result i32)
+       (i32.shr_u (local.get $p1) (i32.const 0))))`,
+    "shrU32_zeroR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: `2a0003e2  mov w2, w0
+             2a0203e1  mov w1, w2
+             2a0103e0  mov w0, w1`,
+     arm:   `e1a02000  mov r2, r0
+             e1a01002  mov r1, r2
+             e1a00001  mov r0, r1`
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "shrU64_zeroR") (param $p1 i64) (result i64)
+       (i64.shr_u (local.get $p1) (i64.const 0))))`,
+    "shrU64_zeroR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "shrS32_zeroR") (param $p1 i32) (result i32)
+       (i32.shr_s (local.get $p1) (i32.const 0))))`,
+    "shrS32_zeroR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: `2a0003e2  mov w2, w0
+             2a0203e1  mov w1, w2
+             13007c20  sbfx w0, w1, #0, #32`,
+     arm:   `e1a02000  mov r2, r0
+             e1a01002  mov r1, r2
+             e1a00001  mov r0, r1`
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "shrS64_zeroR") (param $p1 i64) (result i64)
+       (i64.shr_s (local.get $p1) (i64.const 0))))`,
+    "shrS64_zeroR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+
+// Identities involving addition
+//
+//  x + 0   =>  x
+//  0 + x   =>  x
+//  x + x   =>  x << 1
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "add32_zeroR") (param $p1 i32) (result i32)
+       (i32.add (local.get $p1) (i32.const 0))))`,
+    "add32_zeroR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "add64_zeroR") (param $p1 i64) (result i64)
+       (i64.add (local.get $p1) (i64.const 0))))`,
+    "add64_zeroR",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "add32_zeroL") (param $p1 i32) (result i32)
+       (i32.add (i32.const 0) (local.get $p1))))`,
+    "add32_zeroL",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "add64_zeroL") (param $p1 i64) (result i64)
+       (i64.add (i64.const 0) (local.get $p1))))`,
+    "add64_zeroL",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "add32_self") (param $p1 i32) (result i32)
+       (i32.add (local.get $p1) (local.get $p1))))`,
+    "add32_self",
+    {x64:   `8b cf  mov  %edi, %ecx
+             8b c1  mov  %ecx, %eax
+             03 c1  add  %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax
+             03 45 10  addl 0x10\\(%rbp\\), %eax`,
+     arm64: `0b000000  add  w0, w0, w0`,
+     arm:   `e0900000  adds r0, r0, r0 `
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "add64_self") (param $p1 i64) (result i64)
+       (i64.add (local.get $p1) (local.get $p1))))`,
+    "add64_self",
+    // FIXME outstandingly bad 32-bit sequences, probably due to the RA
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 03 c1  add %rcx, %rax`,
+     x86:   // -0x21524111 is 0xDEADBEEF
+            `8b 5d 14        movl 0x14\\(%rbp\\), %ebx
+             8b 4d 10        movl 0x10\\(%rbp\\), %ecx
+             bf ef be ad de  mov \\$-0x21524111, %edi
+             8b 55 14        movl 0x14\\(%rbp\\), %edx
+             8b 45 10        movl 0x10\\(%rbp\\), %eax
+             03 c1           add %ecx, %eax
+             13 d3           adc %ebx, %edx`,
+     arm64: `8b000000  add  x0, x0, x0`,
+     arm:   // play Musical Chairs for a while
+            `e1a03001  mov  r3, r1
+             e1a02000  mov  r2, r0
+             e1a05003  mov  r5, r3
+             e1a04002  mov  r4, r2
+             e1a01003  mov  r1, r3
+             e1a00002  mov  r0, r2
+             e0900004  adds r0, r0, r4
+             e0a11005  adc  r1, r1, r5`
+    },
+    {x86: {no_prefix:true}}
+);
+
+// Identities involving subtraction
+//
+//  x - 0   =>  x
+//  0 - x   =>  -x
+//  x - x   =>  0
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "sub32_zeroR") (param $p1 i32) (result i32)
+       (i32.sub (local.get $p1) (i32.const 0))))`,
+    "sub32_zeroR",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax`,
+     arm64: ``,
+     arm:   ``
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "sub64_zeroR") (param $p1 i64) (result i64)
+       (i64.sub (local.get $p1) (i64.const 0))))`,
+    "sub64_zeroR",
+    // FIXME folding missing for all 4 targets
+    {x64:   `48 89 f9     mov %rdi, %rcx
+             48 89 c8     mov %rcx, %rax
+             48 83 e8 00  sub \\$0x00, %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax
+             83 ea 00  sub  \\$0x00, %edx`,
+     arm64: ``,
+     arm:   `e2500000  subs r0, r0, #0
+             e2c11000  sbc  r1, r1, #0`
+    },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "sub32_zeroL") (param $p1 i32) (result i32)
+       (i32.sub (i32.const 0) (local.get $p1))))`,
+    "sub32_zeroL",
+    {x64:   `8b cf     mov %edi, %ecx
+             8b c1     mov %ecx, %eax
+             f7 d8     neg %eax`,
+     x86:   `8b 45 10  movl 0x10\\(%rbp\\), %eax
+             f7 d8     neg %eax`,
+     arm64: `4b0003e0  neg w0, w0 `,
+     arm:   `e2600000  rsb r0, r0, #0`
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "sub64_zeroL") (param $p1 i64) (result i64)
+       (i64.sub (i64.const 0) (local.get $p1))))`,
+    "sub64_zeroL",
+    {x64:   `48 89 f9  mov %rdi, %rcx
+             48 89 c8  mov %rcx, %rax
+             48 f7 d8  neg %rax`,
+     x86:   `8b 55 14  movl 0x14\\(%rbp\\), %edx
+             8b 45 10  movl 0x10\\(%rbp\\), %eax
+             f7 d8     neg %eax
+             83 d2 00  adc \\$0x00, %edx
+             f7 da     neg %edx`,
+     arm64: `cb0003e0  neg  x0, x0`,
+     arm:   `e2700000  rsbs r0, r0, #0
+             e2e11000  rsc  r1, r1, #0`
+    },
+    {x86: {no_prefix:true}}
+);
+
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "sub32_self") (param $p1 i32) (result i32)
+       (i32.sub (local.get $p1) (local.get $p1))))`,
+    "sub32_self",
+    {x64:   `33 c0  xor %eax, %eax`,
+     x86:   `33 c0  xor %eax, %eax`,
+     arm64: `52800000  mov w0, #0x0`,
+     arm:   `e3a00000  mov r0, #0`
+    },
+    {x86: {no_prefix:true}}
+);
+codegenTestMultiplatform_adhoc(
+    `(module (func (export "sub64_self") (param $p1 i64) (result i64)
+       (i64.sub (local.get $p1) (local.get $p1))))`,
+    "sub64_self",
+    // FIXME folding missing for all 4 targets
+    {x64:   `48 89 f9        mov %rdi, %rcx
+             48 89 c8        mov %rcx, %rax
+             48 2b c1        sub %rcx, %rax`,
+     x86:   // -0x21524111 is 0xDEADBEEF
+            `8b 5d 14        movl 0x14\\(%rbp\\), %ebx
+             8b 4d 10        movl 0x10\\(%rbp\\), %ecx
+             bf ef be ad de  mov  \\$-0x21524111, %edi
+             8b 55 14        movl 0x14\\(%rbp\\), %edx
+             8b 45 10        movl 0x10\\(%rbp\\), %eax
+             2b c1           sub %ecx, %eax
+             1b d3           sbb %ebx, %edx`,
+     arm64: `cb000000  sub  x0, x0, x0`,
+     arm:   `e1a03001  mov  r3, r1
+             e1a02000  mov  r2, r0
+             e1a05003  mov  r5, r3
+             e1a04002  mov  r4, r2
+             e1a01003  mov  r1, r3
+             e1a00002  mov  r0, r2
+             e0500004  subs r0, r0, r4
+             e0c11005  sbc  r1, r1, r5`
+    },
+    {x86: {no_prefix:true}}
+);
diff --git a/js/src/jit-test/tests/wasm/ion-args.js b/js/src/jit-test/tests/wasm/ion-args.js
new file mode 100644
index 0000000000..69c349f36e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-args.js
@@ -0,0 +1,141 @@
+let { exports } = wasmEvalText(`(module
+    (func (export "i32") (param i32) (result i32)
+     local.get 0
+    )
+
+    (func (export "f32") (param f32) (result f32)
+     local.get 0
+    )
+
+    (func (export "f64") (param f64) (result f64)
+     local.get 0
+    )
+
+    (func (export "mixed_args")
+        (param i32) (param i32) (param i32) (param i32) (param i32) ;; 5 i32
+        (param $f64 f64) ;; 1 f64
+        (param i32)
+        (result f64)
+     local.get $f64
+    )
+)`);
+
+const options = getJitCompilerOptions();
+const jitThreshold = options['ion.warmup.trigger'] * 2 + 2;
+
+let coercions = {
+    i32(x) { return x|0; },
+    f32(x) { return Math.fround(x); },
+    f64(x) { return +x; }
+}
+
+function call(func, coercion, arg) {
+    let expected;
+    try {
+        expected = coercion(arg);
+    } catch(e) {
+        expected = e.message;
+    }
+
+    for (var i = jitThreshold; i --> 0;) {
+        try {
+            assertEq(func(arg), expected);
+        } catch(e) {
+            assertEq(e.message, expected);
+        }
+    }
+}
+
+// Test misc kinds of arguments.
+(function() {
+    const inputs = [
+        42,
+        3.5,
+        -0,
+        -Infinity,
+        2**32,
+        true,
+        Symbol(),
+        undefined,
+        null,
+        {},
+        { valueOf() { return 13.37; } },
+        "bonjour"
+    ];
+
+    for (let arg of inputs) {
+        for (let func of ['i32', 'f32', 'f64']) {
+            call(exports[func], coercions[func], arg);
+        }
+    }
+})();
+
+// Test mixup of float and int arguments.
+(function() {
+    for (let i = 0; i < 10; i++) {
+        assertEq(exports.mixed_args(i, i+1, i+2, i+3, i+4, i+0.5, i+5), i+0.5);
+    }
+})();
+
+// Test high number of arguments.
+// All integers.
+let {func} = wasmEvalText(`(module
+    (func (export "func")
+        ${Array(32).join('(param i32)')}
+        (param $last i32)
+        (result i32)
+     local.get $last
+    )
+)`).exports;
+
+(function() {
+    for (let i = 0; i < 10; i++) {
+        assertEq(func(i, i+1, i+2, i+3, i+4, i+5, i+6, i+7, i+8, i+9, i+10, i+11, i+12, i+13, i+14, i+15,
+                      i+16, i+17, i+18, i+19, i+20, i+21, i+22, i+23, i+24, i+25, i+26, i+27, i+28, i+29, i+30, i+31
+                 ), i+31);
+    }
+})();
+
+// All floats.
+func = wasmEvalText(`(module
+    (func (export "func")
+        ${Array(32).join('(param f64)')}
+        (param $last i32)
+        (result i32)
+     local.get $last
+    )
+)`).exports.func;
+
+(function() {
+    for (let i = 0; i < 10; i++) {
+        assertEq(func(i, i+1, i+2, i+3, i+4, i+5, i+6, i+7, i+8, i+9, i+10, i+11, i+12, i+13, i+14, i+15,
+                      i+16, i+17, i+18, i+19, i+20, i+21, i+22, i+23, i+24, i+25, i+26, i+27, i+28, i+29, i+30, i+31
+                 ), i+31);
+    }
+})();
+
+// Mix em up! 1 i32, then 1 f32, then 1 f64, and again up to 32 args.
+let params = [];
+for (let i = 0; i < 32; i++) {
+    params.push((i % 3 == 0) ? 'i32' :
+                (i % 3 == 1) ? 'f32' :
+                'f64'
+               );
+}
+
+func = wasmEvalText(`(module
+    (func (export "func")
+        ${Array(32).join('(param f64)')}
+        (param $last i32)
+        (result i32)
+     local.get $last
+    )
+)`).exports.func;
+
+(function() {
+    for (let i = 0; i < 10; i++) {
+        assertEq(func(i, i+1, i+2, i+3, i+4, i+5, i+6, i+7, i+8, i+9, i+10, i+11, i+12, i+13, i+14, i+15,
+                      i+16, i+17, i+18, i+19, i+20, i+21, i+22, i+23, i+24, i+25, i+26, i+27, i+28, i+29, i+30, i+31
+                 ), i+31);
+    }
+})();
diff --git a/js/src/jit-test/tests/wasm/ion-asmjs-ctor.js b/js/src/jit-test/tests/wasm/ion-asmjs-ctor.js
new file mode 100644
index 0000000000..0cc0bcb821
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-asmjs-ctor.js
@@ -0,0 +1,12 @@
+evaluate(`
+  var f = (function module() {
+    "use asm";
+    function f(i) {
+        i=i|0;
+        if (!i)
+            return;
+    }
+    return f;
+  })();
+  evaluate(\`new f({}, {});\`);
+`);
diff --git a/js/src/jit-test/tests/wasm/ion-debugger.js b/js/src/jit-test/tests/wasm/ion-debugger.js
new file mode 100644
index 0000000000..13d09d83b6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-debugger.js
@@ -0,0 +1,19 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+var g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval("Debugger(parent).onExceptionUnwind = function () {};");
+lfModule = new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (export "f" (func $func0))
+  (func $func0 (result i32)
+    i32.const -1
+  )
+)
+`));
+processModule(lfModule);
+function processModule(module, jscode) {
+    for (let i = 0; i < 2; ++i) {
+        imports = {}
+        instance = new WebAssembly.Instance(module, imports);
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/ion-error-ool.js b/js/src/jit-test/tests/wasm/ion-error-ool.js
new file mode 100644
index 0000000000..910432d0ba
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-error-ool.js
@@ -0,0 +1,77 @@
+// |jit-test| skip-if: !getJitCompilerOptions()['baseline.enable']
+// These tests need at least baseline to make sense.
+
+const { assertStackTrace, startProfiling, endProfiling, assertEqPreciseStacks } = WasmHelpers;
+
+const options = getJitCompilerOptions();
+const TRIGGER = options['baseline.warmup.trigger'] + 10;
+const ITER = 2 * TRIGGER;
+const EXCEPTION_ITER = TRIGGER + 5;
+
+const SLOW_ENTRY_STACK = ['', '!>', '0,!>', '!>', ''];
+const FAST_ENTRY_STACK = ['', '>', '0,>', '>', ''];
+const INLINED_CALL_STACK = ['', '0', ''];
+const FAST_OOL_ENTRY_STACK = ['', '>', '<,>', 'ool>,>', '<,>', '>', '0,>', '>', ''];
+const EXCEPTION_ENTRY_STACK = ['', '>', '<,>', 'ool>,>', '<,>', '>', ''];
+
+enableGeckoProfiling();
+
+for (let type of ['i32', 'f32', 'f64']) {
+    var instance = wasmEvalText(`(module
+        (func (export "add") (param ${type}) (param ${type}) (result ${type})
+         local.get 0
+         local.get 1
+         ${type}.add
+        )
+    )`).exports;
+
+    function loopBody(a, b) {
+        var caught = null;
+        try {
+            instance.add(a, b);
+        } catch(e) {
+            assertEq(e.message, "ph34r");
+            assertStackTrace(e, ['innerValueOf', 'outerValueOf', 'loopBody', 'main', '']);
+            caught = e;
+        }
+        assertEq(!!caught, b === EXCEPTION_ITER);
+    }
+
+    var x = 0;
+    function main() {
+        let observedStacks = [0, 0, 0];
+        for (var i = 0; i < ITER; i++) {
+            startProfiling();
+            loopBody(i + 1, i + EXCEPTION_ITER + 1);
+            assertEqPreciseStacks(endProfiling(), [INLINED_CALL_STACK, FAST_ENTRY_STACK, SLOW_ENTRY_STACK]);
+
+            if (i === EXCEPTION_ITER) {
+                x = { valueOf: function innerValueOf() { throw new Error("ph34r"); }};
+            } else {
+                x = i;
+            }
+
+            startProfiling();
+            loopBody({valueOf: function outerValueOf() { return x|0; }}, i);
+            let stack = endProfiling();
+            let which = assertEqPreciseStacks(stack, [FAST_OOL_ENTRY_STACK, SLOW_ENTRY_STACK, EXCEPTION_ENTRY_STACK]);
+            if (which !== null) {
+                if (i === EXCEPTION_ITER) {
+                    assertEq(which, 2);
+                }
+                observedStacks[which]++;
+            }
+        }
+
+        let sum = observedStacks.reduce((acc, x) => acc + x);
+        assertEq(sum === 0 || sum === ITER, true);
+        if (sum === ITER) {
+            assertEq(observedStacks[0] > 0, true, "the fast entry should have been taken at least once");
+            assertEq(observedStacks[2], 1, "the error path should have been taken exactly once");
+        }
+    }
+
+    main();
+}
+
+disableGeckoProfiling();
diff --git a/js/src/jit-test/tests/wasm/ion-error-throw.js b/js/src/jit-test/tests/wasm/ion-error-throw.js
new file mode 100644
index 0000000000..c760dbe237
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-error-throw.js
@@ -0,0 +1,43 @@
+// |jit-test| skip-if: !getJitCompilerOptions()['baseline.enable']
+// These tests need at least baseline to make sense.
+
+const { assertStackTrace, startProfiling, endProfiling, assertEqPreciseStacks } = WasmHelpers;
+
+enableGeckoProfiling();
+
+let { add } = wasmEvalText(`(module
+    (func (export "add") (param i32) (param i32) (result i32)
+     local.get 0
+     i32.const 42
+     i32.eq
+     if
+         unreachable
+     end
+
+     local.get 0
+     local.get 1
+     i32.add
+    )
+)`).exports;
+
+const SLOW_ENTRY_STACK = ['', '!>', '0,!>', '!>', ''];
+const FAST_ENTRY_STACK = ['', '>', '0,>', '>', ''];
+const FAST_ENTRY_STACK_THROW = ['', '>', '0,>', '>', '', '>', ''];
+const INLINED_CALL_STACK = ['', '0', ''];
+
+function main() {
+    for (let i = 0; i < 50; i++) {
+        startProfiling();
+        try {
+            assertEq(add(i, i+1), 2*i+1);
+        } catch (e) {
+            assertEq(i, 42);
+            assertEq(e.message.includes("unreachable"), true);
+            assertStackTrace(e, ['wasm-function[0]', 'main', '']);
+        }
+        let stack = endProfiling();
+        assertEqPreciseStacks(stack, [INLINED_CALL_STACK, FAST_ENTRY_STACK, FAST_ENTRY_STACK_THROW, SLOW_ENTRY_STACK]);
+    }
+}
+
+main();
diff --git a/js/src/jit-test/tests/wasm/ion-error-trace.js b/js/src/jit-test/tests/wasm/ion-error-trace.js
new file mode 100644
index 0000000000..cd9d9dd1ad
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-error-trace.js
@@ -0,0 +1,126 @@
+///////////////////////////////////////////////////////////////////////////////
+// FIRST TEST /////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+(function() {
+
+function debug() {
+    throw new Error('gotcha');
+}
+
+var imports = {
+    numCalls:0,
+    main: {
+        f() {
+            debug();
+        }
+    }
+};
+
+var instance = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`(module
+    (import "main" "f" (func))
+    (func (export "add") (param i32) (param i32) (result i32)
+     local.get 0
+     local.get 1
+     call 2
+    )
+    (func (param i32) (param i32) (result i32)
+     local.get 0
+     i32.const 5000
+     i32.eq
+     if
+         call 0
+     end
+
+     local.get 0
+     local.get 1
+     i32.add
+    )
+)`)), imports).exports;
+
+function loopBody(i) {
+    var caught = null;
+    try {
+        assertEq(instance.add(i, i), 2 * i);
+    } catch(e) {
+        // TODO check stack trace
+        print(e.stack);
+        caught = e;
+    }
+    assertEq(!!caught, i === 5000);
+}
+
+function main() {
+    for (var i = 0; i < 100000; i++) {
+        loopBody(i);
+    }
+    assertEq(i, 100000);
+}
+
+main();
+
+})();
+
+///////////////////////////////////////////////////////////////////////////////
+// SECOND TEST ////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+(function() {
+
+function debug() {
+    gc();
+}
+
+var imports = {
+    numCalls:0,
+    main: {
+        f() {
+            debug();
+        }
+    }
+};
+
+var instance = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`(module
+    (import "main" "f" (func))
+    (func (export "add") (param i32) (param i32) (result i32)
+     local.get 0
+     local.get 1
+     call 2
+    )
+    (func (param i32) (param i32) (result i32)
+     local.get 0
+     i32.const 5000
+     i32.eq
+     if
+         call 0
+         unreachable
+     end
+
+     local.get 0
+     local.get 1
+     i32.add
+    )
+)`)), imports).exports;
+
+function loopBody(i) {
+    var caught = null;
+    try {
+        assertEq(instance.add(i, i), 2 * i);
+    } catch(e) {
+        // TODO check stack trace
+        print(e.stack);
+        caught = e;
+    }
+    assertEq(!!caught, i === 5000);
+}
+
+function main() {
+    for (var i = 0; i < 100000; i++) {
+        loopBody(i);
+    }
+    assertEq(i, 100000);
+}
+
+main();
+
+})();
diff --git a/js/src/jit-test/tests/wasm/ion-gc.js b/js/src/jit-test/tests/wasm/ion-gc.js
new file mode 100644
index 0000000000..358afb2548
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-gc.js
@@ -0,0 +1,53 @@
+// |jit-test| skip-if: !getJitCompilerOptions()['baseline.enable']
+// These tests need at least baseline to make sense.
+
+const options = getJitCompilerOptions();
+const TRIGGER = options['baseline.warmup.trigger'] + 10;
+const ITER = 2 * TRIGGER;
+const EXCEPTION_ITER = TRIGGER + 5;
+
+for (let type of ['i32', 'f32', 'f64']) {
+    var instance = wasmEvalText(`(module
+        (func $add (export "add") (param ${type}) (param ${type}) (result ${type})
+         local.get 0
+         local.get 1
+         ${type}.add
+        )
+    )`).exports;
+
+    function loopBody(a, b) {
+        var caught = null;
+        try {
+            instance.add(a, b);
+        } catch(e) {
+            caught = e;
+        }
+        assertEq(!!caught, b === EXCEPTION_ITER);
+    }
+
+    var x = 0;
+    function main() {
+        for (var i = 0; i <= EXCEPTION_ITER; i++) {
+            loopBody(i + 1, i + EXCEPTION_ITER + 1);
+
+            let otherArg = { valueOf() { return i|0; } };
+
+            if (i === EXCEPTION_ITER) {
+                x = { valueOf: function innerValueOf() {
+                    // Supress callee.
+                    instance = null;
+                    // Suppress other arguments.
+                    otherArg = null;
+                    gc();
+                    return 42;
+                }};
+            } else {
+                x = i;
+            }
+
+            loopBody({valueOf: function outerValueOf() { return x|0; }}, otherArg);
+        }
+    }
+
+    main();
+}
diff --git a/js/src/jit-test/tests/wasm/ion-lazy-tables.js b/js/src/jit-test/tests/wasm/ion-lazy-tables.js
new file mode 100644
index 0000000000..b4a868170e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion-lazy-tables.js
@@ -0,0 +1,68 @@
+// |jit-test| skip-if: !getJitCompilerOptions()['baseline.enable']
+// These tests need at least baseline to make sense.
+
+const { assertStackTrace, startProfiling, endProfiling, assertEqPreciseStacks } = WasmHelpers;
+
+const options = getJitCompilerOptions();
+const TRIGGER = options['baseline.warmup.trigger'] + 10;
+const ITER = 2 * TRIGGER;
+const EXCEPTION_ITER = TRIGGER + 5;
+
+const SLOW_ENTRY_STACK = ['', '!>', '0,!>', '!>', ''];
+const FAST_ENTRY_STACK = ['', '>', '0,>', '>', ''];
+const INLINED_CALL_STACK = ['', '0', ''];
+const EXPECTED_STACKS = [SLOW_ENTRY_STACK, FAST_ENTRY_STACK, INLINED_CALL_STACK];
+
+function main() {
+    var { table } = wasmEvalText(`(module
+        (func (param i32) (param i32) (result i32)
+         local.get 0
+         local.get 1
+         i32.add
+        )
+        (table (export "table") 10 funcref)
+        (elem (i32.const 0) 0)
+    )`).exports;
+
+    for (var i = 0; i < ITER; i++) {
+        startProfiling();
+        assertEq(table.get(0)(i, i+1), i*2+1);
+        assertEqPreciseStacks(endProfiling(), EXPECTED_STACKS);
+    }
+}
+
+function withTier2() {
+    setJitCompilerOption('wasm.delay-tier2', 1);
+
+    var module = new WebAssembly.Module(wasmTextToBinary(`(module
+        (func (param i32) (param i32) (result i32)
+         local.get 0
+         local.get 1
+         i32.add
+        )
+        (table (export "table") 10 funcref)
+        (elem (i32.const 0) 0)
+    )`));
+    var { table } = new WebAssembly.Instance(module).exports;
+
+    let i = 0;
+    do {
+        i++;
+        startProfiling();
+        assertEq(table.get(0)(i, i+1), i*2+1);
+        assertEqPreciseStacks(endProfiling(), EXPECTED_STACKS);
+    } while (!wasmHasTier2CompilationCompleted(module));
+
+    for (i = 0; i < ITER; i++) {
+        startProfiling();
+        assertEq(table.get(0)(i, i+1), i*2+1);
+        assertEqPreciseStacks(endProfiling(), EXPECTED_STACKS);
+    }
+
+    setJitCompilerOption('wasm.delay-tier2', 0);
+}
+
+enableGeckoProfiling();
+main();
+withTier2();
+disableGeckoProfiling();
diff --git a/js/src/jit-test/tests/wasm/ion2wasm.js b/js/src/jit-test/tests/wasm/ion2wasm.js
new file mode 100644
index 0000000000..abd88a0406
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ion2wasm.js
@@ -0,0 +1,174 @@
+var ITERATIONS = 10;
+var INNER_ITERATIONS = 100;
+
+let instance = wasmEvalText(`(module
+    (func (export "add") (param i32) (param i32) (result i32)
+     local.get 0
+     local.get 1
+     i32.add
+    )
+
+    (func (export "no_arg") (result i32)
+     i32.const 42
+     i32.const 58
+     i32.add
+    )
+
+    (global $g (mut i32) (i32.const 0))
+
+    (func (export "set_global_one") (param i32)
+     local.get 0
+     global.set $g
+    )
+
+    (func (export "set_global_two") (param i32) (param i32)
+     local.get 0
+     local.get 1
+     i32.add
+     global.set $g
+    )
+
+    (func (export "glob") (result i32)
+     global.get $g
+    )
+)`).exports;
+
+function run(name, func) {
+    for (let i = ITERATIONS; i --> 0;) {
+        func();
+    }
+}
+
+function testCallKnown() {
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(instance.add(i, i + 1), 2*i + 1);
+    }
+}
+
+function testCallKnownRectifying() {
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(instance.add(i + 1), i+1);
+    }
+}
+
+function jsAdd(x, y) {
+    return (x|0) + (y|0) | 0;
+}
+
+function testCallGeneric() {
+    var arr = [instance.add, jsAdd];
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(arr[i%2](i, i+1), 2*i + 1);
+    }
+}
+
+function testCallGenericRectifying() {
+    var arr = [instance.add, jsAdd];
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(arr[i%2](i+1), i + 1);
+    }
+}
+
+function testCallScriptedGetter() {
+    var obj = {};
+    Object.defineProperty(obj, 'x', {
+        get: instance.no_arg
+    });
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(obj.x, 100);
+    }
+}
+
+function testCallScriptedGetterRectifying() {
+    var obj = {};
+    Object.defineProperty(obj, 'x', {
+        // Missing two arguments.
+        get: instance.add
+    });
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(obj.x, 0);
+    }
+}
+
+function testCallScriptedSetter() {
+    var obj = {};
+    Object.defineProperty(obj, 'x', {
+        set: instance.set_global_one
+    });
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        obj.x = i;
+    }
+    assertEq(instance.glob(), INNER_ITERATIONS-1);
+}
+
+function testCallScriptedSetterRectifying() {
+    var obj = {};
+    Object.defineProperty(obj, 'x', {
+        set: instance.set_global_two
+    });
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        obj.x = i;
+    }
+    assertEq(instance.glob(), INNER_ITERATIONS-1);
+}
+
+function testFunctionApplyArray() {
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(instance.add.apply(null, [i, i + 1]), 2*i+1);
+    }
+}
+
+function testFunctionApplyArrayRectifying() {
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(instance.add.apply(null, [i + 1]), i+1);
+    }
+}
+
+function testFunctionApplyArgs() {
+    function wrapper() {
+        assertEq(instance.add.apply(null, arguments), 2*arguments[0]+1);
+    }
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        wrapper(i, i + 1);
+    }
+}
+
+function testFunctionApplyArgsRectifying() {
+    function wrapper() {
+        assertEq(instance.add.apply(null, arguments), arguments[0]);
+    }
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        wrapper(i + 1);
+    }
+}
+
+function testFunctionCall() {
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(instance.add.call(null, i, i + 1), 2*i+1);
+    }
+}
+
+function testFunctionCallRectifying() {
+    for (let i = 0; i < INNER_ITERATIONS; i++) {
+        assertEq(instance.add.call(null, i + 1), i+1);
+    }
+}
+
+run('call known', testCallKnown);
+run('call known rectifying', testCallKnownRectifying);
+
+run('call generic', testCallGeneric);
+run('call generic rectifying', testCallGenericRectifying);
+
+run('scripted getter', testCallScriptedGetter);
+run('scripted getter rectifiying', testCallScriptedGetterRectifying);
+run('scripted setter', testCallScriptedSetter);
+run('scripted setter rectifiying', testCallScriptedSetterRectifying);
+
+run('function.apply array', testFunctionApplyArray);
+run('function.apply array rectifying', testFunctionApplyArrayRectifying);
+run('function.apply args', testFunctionApplyArgs);
+run('function.apply args rectifying', testFunctionApplyArgsRectifying);
+
+run('function.call', testFunctionCall);
+run('function.call rectifying', testFunctionCallRectifying);
diff --git a/js/src/jit-test/tests/wasm/js-reexport.js b/js/src/jit-test/tests/wasm/js-reexport.js
new file mode 100644
index 0000000000..023007728b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/js-reexport.js
@@ -0,0 +1,62 @@
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const Memory = WebAssembly.Memory;
+const Table = WebAssembly.Table;
+
+function accum(...args) {
+    var sum = 0;
+    for (var i = 0; i < args.length; i++)
+        sum += args[i];
+    return sum;
+}
+
+var e = wasmEvalText(`(module
+    (import "" "a" (func $a (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)))
+    (import "" "b" (func $b (param f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32) (result f32)))
+    (import "" "c" (func $c (param f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64 f64) (result f64)))
+    (import "" "d" (func $d (param i32 f32 f64 i32 f32 f64 i32 f32 f64 i32 f32 f64 i32 f32 f64 i32 f32 f64 i32 f32) (result f64)))
+    (func (export "a") (result i32)
+        i32.const 1 i32.const 2 i32.const 3 i32.const 4 i32.const 5
+        i32.const 6 i32.const 7 i32.const 8 i32.const 9 i32.const 10
+        i32.const 11 i32.const 12 i32.const 13 i32.const 14 i32.const 15
+        i32.const 16 i32.const 17 i32.const 18 i32.const 19 i32.const 20
+        call $a
+    )
+    (func (export "b") (result f32)
+        f32.const 1.1 f32.const 2.1 f32.const 3.1 f32.const 4.1 f32.const 5.1
+        f32.const 6.1 f32.const 7.1 f32.const 8.1 f32.const 9.1 f32.const 10.1
+        f32.const 11.1 f32.const 12.1 f32.const 13.1 f32.const 14.1 f32.const 15.1
+        f32.const 16.1 f32.const 17.1 f32.const 18.1 f32.const 19.1 f32.const 20.1
+        call $b
+    )
+    (func (export "c") (result f64)
+        f64.const 1.2 f64.const 2.2 f64.const 3.2 f64.const 4.2 f64.const 5.2
+        f64.const 6.2 f64.const 7.2 f64.const 8.2 f64.const 9.2 f64.const 10.2
+        f64.const 11.2 f64.const 12.2 f64.const 13.2 f64.const 14.2 f64.const 15.2
+        f64.const 16.2 f64.const 17.2 f64.const 18.2 f64.const 19.2 f64.const 20.2
+        call $c
+    )
+    (func (export "d") (result f64)
+        i32.const 1 f32.const 2.3 f64.const 3.3 i32.const 4 f32.const 5.3
+        f64.const 6.3 i32.const 7 f32.const 8.3 f64.const 9.3 i32.const 10
+        f32.const 11.3 f64.const 12.3 i32.const 13 f32.const 14.3 f64.const 15.3
+        i32.const 16 f32.const 17.3 f64.const 18.3 i32.const 19 f32.const 20.3
+        call $d
+    )
+)`, {"":{a:accum, b:accum, c:accum, d:accum, e:accum}}).exports;
+
+const epsilon = .00001;
+assertEq(e.a(), 210);
+assertEq(Math.abs(e.b() - 212) < epsilon, true);
+assertEq(Math.abs(e.c() - 214) < epsilon, true);
+assertEq(Math.abs(e.d() - 213.9) < epsilon, true);
+
+setJitCompilerOption("baseline.warmup.trigger", 5);
+setJitCompilerOption("ion.warmup.trigger", 10);
+
+var e = wasmEvalText(`(module
+    (import "" "a" (func $a (param i32 f64) (result f64)))
+    (export "a" (func $a))
+)`, {"":{a:(a,b)=>a+b}}).exports;
+for (var i = 0; i < 100; i++)
+    assertEq(e.a(1.5, 2.5), 3.5);
diff --git a/js/src/jit-test/tests/wasm/js-types/directives.txt b/js/src/jit-test/tests/wasm/js-types/directives.txt
new file mode 100644
index 0000000000..01f722ba1e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/js-types/directives.txt
@@ -0,0 +1 @@
+|jit-test| include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/js-types/table-js-funcs.js b/js/src/jit-test/tests/wasm/js-types/table-js-funcs.js
new file mode 100644
index 0000000000..92b6c462ef
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/js-types/table-js-funcs.js
@@ -0,0 +1,26 @@
+// |jit-test| skip-if: !('Function' in WebAssembly)
+
+function testfunc(n) {}
+
+const table = new WebAssembly.Table({element: "anyfunc", initial: 3});
+const func1 = new WebAssembly.Function({parameters: ["i32"], results: []}, testfunc);
+table.set(0, func1);
+const func2 = new WebAssembly.Function({parameters: ["f32"], results: []}, testfunc);
+table.set(1, func2);
+const func3 = new WebAssembly.Function({parameters: ["i64"], results: []}, testfunc);
+table.set(2, func3);
+
+const first = table.get(0);
+assertEq(first instanceof WebAssembly.Function, true);
+assertEq(first, func1);
+assertEq(first.type().parameters[0], func1.type().parameters[0]);
+
+const second = table.get(1);
+assertEq(second instanceof WebAssembly.Function, true);
+assertEq(second, func2);
+assertEq(second.type().parameters[0], func2.type().parameters[0]);
+
+const third = table.get(2);
+assertEq(third instanceof WebAssembly.Function, true);
+assertEq(third, func3);
+assertEq(third.type().parameters[0], func3.type().parameters[0]);
diff --git a/js/src/jit-test/tests/wasm/large-memory.js b/js/src/jit-test/tests/wasm/large-memory.js
new file mode 100644
index 0000000000..20c9c3b371
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/large-memory.js
@@ -0,0 +1,328 @@
+// |jit-test| skip-if: !largeArrayBufferSupported(); allow-oom
+
+var pagesz = PageSizeInBytes;
+var pages_limit = MaxPagesIn32BitMemory;
+
+// 40000 is well above 2GB but not anything that might run into boundary
+// conditions near 4GB.
+var pages_vanilla = 40000;
+
+for ( let [pages,maxpages] of [[pages_vanilla, pages_vanilla+100],
+                               [pages_limit - 3, pages_limit],
+                               [pages_limit, pages_limit]] ) {
+    assertEq(pages == maxpages || maxpages - pages >= 3, true)
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") ${pages} ${maxpages})
+
+  (data (i32.const ${(pages-5)*pagesz}) "yabbadabbado")
+  (data $flintstone "yabbadabbado")
+
+  (func (export "get_constaddr") (result i32)
+    (i32.load (i32.const ${pages*pagesz-4})))
+
+  (func (export "get_varaddr") (param $p i32) (result i32)
+    (i32.load (local.get $p)))
+
+  (func (export "set_constaddr") (param $v i32)
+    (i32.store (i32.const ${pages*pagesz-8}) (local.get $v)))
+
+  (func (export "set_varaddr") (param $p i32) (param $v i32)
+    (i32.store (local.get $p) (local.get $v)))
+
+  (func (export "get_constaddr_large_offset") (result i32)
+    (i32.load offset=${(pages-100)*pagesz-4} (i32.const ${pagesz*100})))
+
+  (func (export "get_varaddr_large_offset") (param $p i32) (result i32)
+    (i32.load offset=${(pages-100)*pagesz-4} (local.get $p)))
+
+  (func (export "get_constaddr_small_offset") (result i32)
+    (i32.load offset=${pagesz-4} (i32.const ${(pages-1)*pagesz})))
+
+  (func (export "get_varaddr_small_offset") (param $p i32) (result i32)
+    (i32.load offset=${pagesz-4} (local.get $p)))
+
+  (func (export "set_constaddr_large_offset") (param $v i32)
+    (i32.store offset=${(pages-100)*pagesz-16} (i32.const ${pagesz*100}) (local.get $v)))
+
+  (func (export "set_varaddr_large_offset") (param $p i32) (param $v i32)
+    (i32.store offset=${(pages-100)*pagesz-20} (local.get $p) (local.get $v)))
+
+  (func (export "set_constaddr_small_offset") (param $v i32)
+    (i32.store offset=${pagesz-24} (i32.const ${(pages-1)*pagesz}) (local.get $v)))
+
+  (func (export "set_varaddr_small_offset") (param $p i32) (param $v i32)
+    (i32.store offset=${pagesz-28} (local.get $p) (local.get $v)))
+
+  (func (export "copy") (param $dest i32) (param $src i32)
+    (memory.copy (local.get $dest) (local.get $src) (i32.const 12)))
+
+  (func (export "init") (param $dest i32)
+    (memory.init $flintstone (local.get $dest) (i32.const 0) (i32.const 12)))
+
+  (func (export "fill") (param $dest i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get 0) (local.get 1) (local.get 2)))
+
+  (func (export "grow1") (result i32)
+    (memory.grow (i32.const 1)))
+)`);
+
+    let buf = new Int32Array(ins.exports.mem.buffer);
+
+    let checkFlintstoneAt = function (addr) {
+        assertEq(buf[addr/4], 0x62626179)   // "yabb", little-endian
+        assertEq(buf[addr/4+1], 0x62616461) // "adab", ditto
+        assertEq(buf[addr/4+2], 0x6f646162) // "bado"
+    }
+
+    buf[pages*pagesz/4-1] = 0xdeadbeef;
+    assertEq(ins.exports.get_constaddr(), 0xdeadbeef|0);
+    assertEq(ins.exports.get_varaddr(pages*pagesz-4), 0xdeadbeef|0);
+
+    assertEq(ins.exports.get_constaddr_large_offset(), 0xdeadbeef|0);
+    assertEq(ins.exports.get_varaddr_large_offset(pagesz*100), 0xdeadbeef|0);
+
+    assertEq(ins.exports.get_constaddr_small_offset(), 0xdeadbeef|0);
+    assertEq(ins.exports.get_varaddr_small_offset((pages-1)*pagesz), 0xdeadbeef|0);
+
+    ins.exports.set_constaddr(0xcafebab0);
+    assertEq(buf[pages*pagesz/4-2], 0xcafebab0|0);
+
+    ins.exports.set_varaddr(pages*pagesz-12, 0xcafebab1);
+    assertEq(buf[pages*pagesz/4-3], 0xcafebab1|0);
+
+    ins.exports.set_constaddr_large_offset(0xcafebab2);
+    assertEq(buf[pages*pagesz/4-4], 0xcafebab2|0);
+
+    ins.exports.set_varaddr_large_offset(pagesz*100, 0xcafebab3);
+    assertEq(buf[pages*pagesz/4-5], 0xcafebab3|0);
+
+    ins.exports.set_constaddr_small_offset(0xcafebab4);
+    assertEq(buf[pages*pagesz/4-6], 0xcafebab4|0);
+
+    ins.exports.set_varaddr_small_offset((pages-1)*pagesz, 0xcafebab5);
+    assertEq(buf[pages*pagesz/4-7], 0xcafebab5|0);
+
+    if (pages*pagesz < 0x1_0000_0000) {
+        assertErrorMessage(() => ins.exports.get_varaddr(pages*pagesz),
+                           WebAssembly.RuntimeError,
+                           /index out of bounds/);
+    }
+
+    assertErrorMessage(() => ins.exports.get_varaddr_large_offset(pagesz*100+4),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    assertErrorMessage(() => ins.exports.get_varaddr_small_offset((pages-1)*pagesz+4),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    ins.exports.set_varaddr(pages*pagesz-4, 0); // Should work
+    if (pages*pagesz < 0x1_0000_0000) {
+        assertErrorMessage(() => ins.exports.set_varaddr(pages*pagesz, 0),
+                           WebAssembly.RuntimeError,
+                           /index out of bounds/);
+    }
+
+    ins.exports.set_varaddr_large_offset(pagesz*100+16, 0); // Should work
+    assertErrorMessage(() => ins.exports.set_varaddr_large_offset(pagesz*100+20, 0),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    ins.exports.set_varaddr_small_offset((pages-1)*pagesz+24); // Should work
+    assertErrorMessage(() => ins.exports.set_varaddr_small_offset((pages-1)*pagesz+28, 0),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    // Active init
+    checkFlintstoneAt((pages-5)*pagesz);
+
+    // memory.init
+    ins.exports.init((pages-6)*pagesz);
+    checkFlintstoneAt((pages-6)*pagesz);
+
+    ins.exports.init(pages*pagesz-12); // Should work
+    // Dest goes OOB
+    assertErrorMessage(() => ins.exports.init(pages*pagesz-6),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    // memory.copy
+
+    // Dest and src are in bounds
+    ins.exports.copy((pages-10)*pagesz, (pages-5)*pagesz);
+    checkFlintstoneAt((pages-10)*pagesz);
+
+    // Dest goes OOB
+    assertErrorMessage(() => ins.exports.copy((pages)*pagesz-6, (pages-5)*pagesz, 12),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    ins.exports.copy((pages)*pagesz-12, (pages-1)*pagesz); // Should work
+    // Src goes OOB
+    assertErrorMessage(() => ins.exports.copy((pages)*pagesz-12, (pages)*pagesz-6),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+
+    // memory.fill
+    let lastpg = (pages-1)*pagesz;
+    ins.exports.fill(lastpg, 0x37, pagesz);
+    for ( let i=0; i < pagesz/4; i++ )
+        assertEq(buf[lastpg/4+i], 0x37373737);
+
+    assertErrorMessage(() => ins.exports.fill(lastpg, 0x42, pagesz+1),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    done:
+    if (pages < maxpages) {
+        let res = 0;
+
+        res = ins.exports.grow1();
+        if (res == -1) break done;
+        assertEq(res, pages);
+
+        res = ins.exports.grow1();
+        if (res == -1) break done;
+        assertEq(res, pages+1);
+
+        res = ins.exports.grow1();
+        if (res == -1) break done;
+        assertEq(res, pages+2);
+
+        assertEq(ins.exports.get_varaddr((pages+2)*pagesz), 0);
+
+        let i = 0;
+        while (ins.exports.grow1() != -1) {
+            i++;
+        }
+        // We can't assert equality because we might OOM before we get to the
+        // max, but we can assert we did not go beyond that.
+        assertEq(i <= maxpages-pages-3, true);
+    }
+}
+
+// Very large offsets should be allowed (but may of course be OOB).  Observe
+// that offset=0xffffffff is accepted by the validator even though this access
+// could never succeed.
+{
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") 1)
+  (func (export "get1") (param $p i32) (result i32)
+    (i32.load offset=0x80000000 (local.get $p)))
+  (func (export "get2") (param $p i32) (result i32)
+    (i32.load offset=0xfffffffc (local.get $p)))
+  (func (export "get3") (param $p i32) (result i32)
+    (i32.load offset=0xffffffff (local.get $p))))
+`);
+    assertErrorMessage(() => ins.exports.get1(0),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    assertErrorMessage(() => ins.exports.get2(0),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    assertErrorMessage(() => ins.exports.get3(0),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+}
+
+{
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") 32768)
+  (func (export "get1") (param $p i32) (result i32)
+    (i32.load8_s offset=0x7fffffff (local.get $p))))
+`);
+    assertEq(ins.exports.get1(0), 0);
+    assertErrorMessage(() => ins.exports.get1(1),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    assertErrorMessage(() => ins.exports.get1(-1),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+}
+
+{
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") 32769)
+  (func (export "get1") (param $p i32) (result i32)
+    (i32.load8_s offset=0x80000000 (local.get $p))))
+`);
+    assertEq(ins.exports.get1(0), 0);
+    assertEq(ins.exports.get1(65535), 0);
+    assertErrorMessage(() => ins.exports.get1(65536),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+}
+
+{
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") ${pages_limit})
+  (func (export "get1") (param $p i32) (result i32)
+    (i32.load8_s offset=${pages_limit*pagesz-1} (local.get $p))))
+`);
+    assertEq(ins.exports.get1(0), 0);
+    assertErrorMessage(() => ins.exports.get1(1),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    assertErrorMessage(() => ins.exports.get1(-1),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+}
+
+// Fail to grow at the declared max
+// Import and export
+
+{
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") ${pages_limit} ${pages_limit})
+
+  (func (export "set_it") (param $addr i32) (param $val i32)
+    (i32.store (local.get $addr) (local.get $val)))
+
+  (func (export "grow1") (result i32)
+    (memory.grow (i32.const 1)))
+)`);
+
+    assertEq(ins.exports.grow1(), -1); // Because initial == max
+
+    let ins2 = wasmEvalText(`
+(module
+  (import "" "mem" (memory 1))
+
+  (func (export "get_it") (param $addr i32) (result i32)
+    (i32.load (local.get $addr)))
+)`,
+                            {"":ins.exports})
+
+    ins.exports.set_it((pages_limit*pagesz)-4, 0xbaadf00d);
+    assertEq(ins2.exports.get_it((pages_limit*pagesz)-4), 0xbaadf00d|0)
+}
+
+// Fail to grow at the max heap size even if there is headroom
+// in the declared max
+if (pages_limit < 65536) {
+    let ins = wasmEvalText(`
+(module
+  (memory (export "mem") ${pages_limit} ${pages_limit+2})
+
+  (func (export "grow1") (result i32)
+    (memory.grow (i32.const 1)))
+)`);
+
+    assertEq(ins.exports.grow1(), -1); // Because current is at the max heap size
+}
+
+// Fail to instantiate when the minimum is larger than the max heap size
+if (pages_limit < 65536) {
+    assertErrorMessage(() => wasmEvalText(`
+(module (memory (export "mem") ${pages_limit+1} ${pages_limit+1}))
+`),
+                       WebAssembly.RuntimeError,
+                       /too many memory pages/);
+}
diff --git a/js/src/jit-test/tests/wasm/lazy-stubs-jitentry.js b/js/src/jit-test/tests/wasm/lazy-stubs-jitentry.js
new file mode 100644
index 0000000000..cb846a4d25
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/lazy-stubs-jitentry.js
@@ -0,0 +1,36 @@
+function test() {
+  var table = wasmEvalText(`(module
+        (func $add0 (param i32) (result i32) (i32.add (get_local 0) (i32.const 0)))
+        (func $add1 (param i32) (result i32) (i32.add (get_local 0) (i32.const 1)))
+        (func $add2 (param i32) (result i32) (i32.add (get_local 0) (i32.const 2)))
+        (func $add3 (param i32) (result i32) (i32.add (get_local 0) (i32.const 3)))
+        (func $add4 (param i32) (result i32) (i32.add (get_local 0) (i32.const 4)))
+        (func $add5 (param i32) (result i32) (i32.add (get_local 0) (i32.const 5)))
+        (func $add6 (param i32) (result i32) (i32.add (get_local 0) (i32.const 6)))
+        (func $add7 (param i32) (result i32) (i32.add (get_local 0) (i32.const 7)))
+        (func $add8 (param i32) (result i32) (i32.add (get_local 0) (i32.const 8)))
+        (func $add9 (param i32) (result i32) (i32.add (get_local 0) (i32.const 9)))
+        (table (export "table") 10 funcref)
+        (elem (i32.const 0) $add0)
+        (elem (i32.const 1) $add1)
+        (elem (i32.const 2) $add2)
+        (elem (i32.const 3) $add3)
+        (elem (i32.const 4) $add4)
+        (elem (i32.const 5) $add5)
+        (elem (i32.const 6) $add6)
+        (elem (i32.const 7) $add7)
+        (elem (i32.const 8) $add8)
+        (elem (i32.const 9) $add9)
+    )`).exports.table;
+  var exps = [];
+  for (var i = 0; i < 10; i++) {
+    exps.push(table.get(i));
+  }
+  var res = 0;
+  for (var i = 0; i < 80; i++) {
+    var exp = exps[i % exps.length];
+    res = exp(res);
+  }
+  assertEq(res, 360);
+}
+test();
diff --git a/js/src/jit-test/tests/wasm/limits.js b/js/src/jit-test/tests/wasm/limits.js
new file mode 100644
index 0000000000..7a800446dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/limits.js
@@ -0,0 +1,249 @@
+// Tests of limits of memory and table types
+
+const PageSize = PageSizeInBytes;
+const MemoryMaxValid = 65536;
+const MemoryMaxRuntime = MaxPagesIn32BitMemory;
+
+const TableMaxValid = 0xffff_ffff;
+const TableMaxRuntime = 10_000_000;
+
+// Test that a memory type is valid within a module
+function testMemoryValidate(initial, maximum, shared) {
+  wasmValidateText(`(module
+    (memory ${initial} ${maximum || ''} ${shared ? 'shared' : ''})
+  )`);
+}
+
+testMemoryValidate(0, undefined, false);
+testMemoryValidate(1, undefined, false);
+testMemoryValidate(0, 1, false);
+testMemoryValidate(0, 1, true);
+testMemoryValidate(1, 1, false);
+testMemoryValidate(1, 1, true);
+testMemoryValidate(MemoryMaxValid, undefined, false);
+testMemoryValidate(MemoryMaxValid, MemoryMaxValid, false);
+testMemoryValidate(MemoryMaxValid, MemoryMaxValid, true);
+
+// Test that a memory type is not valid within a module
+function testMemoryFailValidate(initial, maximum, shared, pattern) {
+  wasmFailValidateText(`(module
+    (memory ${initial} ${maximum || ''} ${shared ? 'shared' : ''})
+  )`, pattern);
+}
+
+testMemoryFailValidate(2, 1, false, /size minimum must not be greater than maximum/);
+testMemoryFailValidate(1, undefined, true, /maximum length required for shared memory/);
+testMemoryFailValidate(MemoryMaxValid + 1, undefined, false, /initial memory size too big/);
+testMemoryFailValidate(MemoryMaxValid, MemoryMaxValid + 1, false, /maximum memory size too big/);
+testMemoryFailValidate(MemoryMaxValid, MemoryMaxValid + 1, true, /maximum memory size too big/);
+
+// Test that a memory type is invalid for constructing a WebAssembly.Memory
+function testMemoryFailConstruct(initial, maximum, shared, pattern) {
+  assertErrorMessage(() => new WebAssembly.Memory({
+    initial,
+    maximum,
+    shared
+  }), RangeError, pattern);
+}
+
+// Test initial length, giving a maximum only if required due to being shared
+testMemoryFailConstruct(MemoryMaxValid + 1, undefined, false, /bad Memory initial size/);
+testMemoryFailConstruct(MemoryMaxValid + 1, MemoryMaxValid + 1, true, /bad Memory initial size/);
+// Test maximum length
+testMemoryFailConstruct(0, MemoryMaxValid + 1, false, /bad Memory maximum size/);
+testMemoryFailConstruct(0, MemoryMaxValid + 1, true, /bad Memory maximum size/);
+
+// Test that a memory type can be instantiated within a module or constructed
+// with a WebAssembly.Memory
+function testMemoryCreate(initial, maximum, shared) {
+  // May OOM, but must not fail to validate
+  try {
+      wasmEvalText(`(module
+        (memory ${initial} ${maximum || ''} ${shared ? 'shared' : ''})
+      )`);
+  } catch (e) {
+      assertEq(String(e).indexOf("out of memory") !== -1, true, `${e}`);
+  }
+  try {
+    new WebAssembly.Memory({initial, maximum, shared});
+  } catch (e) {
+    assertEq(String(e).indexOf("out of memory") !== -1, true, `${e}`);
+  }
+}
+
+testMemoryCreate(0, undefined, false);
+testMemoryCreate(1, undefined, false);
+testMemoryCreate(0, 1, false);
+testMemoryCreate(0, 1, true);
+testMemoryCreate(1, 1, false);
+testMemoryCreate(1, 1, true);
+testMemoryCreate(MemoryMaxRuntime, undefined, false);
+testMemoryCreate(MemoryMaxRuntime, MemoryMaxValid, false);
+testMemoryCreate(MemoryMaxRuntime, MemoryMaxValid, true);
+
+// Test that a memory type cannot be instantiated within a module or constructed
+// with a WebAssembly.Memory
+
+if (MemoryMaxRuntime < 65536) {
+    let testMemoryFailCreate = function(initial, maximum, shared) {
+        assertErrorMessage(() => wasmEvalText(`(module
+    (memory ${initial} ${maximum || ''} ${shared ? 'shared' : ''})
+  )`), WebAssembly.RuntimeError, /too many memory pages/);
+        assertErrorMessage(() => new WebAssembly.Memory({
+            initial,
+            maximum,
+            shared
+        }), WebAssembly.RuntimeError, /too many memory pages/);
+    }
+
+    testMemoryFailCreate(MemoryMaxRuntime + 1, undefined, false);
+    testMemoryFailCreate(MemoryMaxRuntime + 1, MemoryMaxValid, false);
+    testMemoryFailCreate(MemoryMaxRuntime + 1, MemoryMaxValid, true);
+} else {
+    let testMemoryFailCreate = function(initial, maximum, shared) {
+        assertErrorMessage(() => wasmEvalText(`(module
+    (memory ${initial} ${maximum || ''} ${shared ? 'shared' : ''})
+  )`), WebAssembly.CompileError, /(initial memory size too big)|(memory size minimum must not be greater than maximum)/);
+        assertErrorMessage(() => new WebAssembly.Memory({
+            initial,
+            maximum,
+            shared
+        }), RangeError, /bad Memory initial size/);
+    }
+
+    testMemoryFailCreate(MemoryMaxRuntime + 1, undefined, false);
+    testMemoryFailCreate(MemoryMaxRuntime + 1, MemoryMaxValid, false);
+    testMemoryFailCreate(MemoryMaxRuntime + 1, MemoryMaxValid, true);
+}
+
+
+// Test that a memory type cannot be grown from initial to a target due to an
+// implementation limit
+function testMemoryFailGrow(initial, maximum, target, shared) {
+  let {run} = wasmEvalText(`(module
+    (memory ${initial} ${maximum || ''} ${shared ? 'shared' : ''})
+    (func (export "run") (result i32)
+      i32.const ${target - initial}
+      memory.grow
+    )
+  )`).exports;
+  assertEq(run(), -1, 'failed to grow');
+
+  let mem = new WebAssembly.Memory({
+    initial,
+    maximum,
+    shared
+  });
+  assertErrorMessage(() => mem.grow(target - initial), RangeError, /failed to grow memory/);
+}
+
+testMemoryFailGrow(1, undefined, MemoryMaxRuntime + 1, false);
+testMemoryFailGrow(1, MemoryMaxValid, MemoryMaxRuntime + 1, false);
+testMemoryFailGrow(1, MemoryMaxValid, MemoryMaxRuntime + 1, true);
+
+// Test that a table type is valid within a module
+function testTableValidate(initial, maximum) {
+  wasmValidateText(`(module
+    (table ${initial} ${maximum || ''} anyfunc)
+  )`);
+}
+
+testTableValidate(0, undefined);
+testTableValidate(1, undefined);
+testTableValidate(0, 1);
+testTableValidate(1, 1);
+testTableValidate(TableMaxValid, undefined);
+testTableValidate(TableMaxValid, TableMaxValid);
+
+// Test that a table type is not valid within a module
+function testTableFailValidate(initial, maximum, pattern) {
+  wasmFailValidateText(`(module
+    (table ${initial} ${maximum || ''} anyfunc)
+  )`, pattern);
+}
+
+testTableFailValidate(2, 1, /size minimum must not be greater than maximum/);
+// The maximum valid table value is equivalent to the maximum encodable limit
+// value, so we cannot test too large of a table limit in a module.
+assertEq(TableMaxValid + 1 > 0xffffffff, true);
+
+// Test that a table type is invalid for constructing a WebAssembly.Table
+function testTableFailConstruct(initial, maximum, pattern) {
+  assertErrorMessage(() => new WebAssembly.Table({
+    initial,
+    maximum,
+    element: 'anyfunc',
+  }), TypeError, pattern);
+}
+
+testTableFailConstruct(TableMaxValid + 1, undefined, /bad Table initial size/);
+testTableFailConstruct(0, TableMaxValid + 1, /bad Table maximum size/);
+
+// Test that a table type can be instantiated within a module or constructed
+// with a WebAssembly.Table
+function testTableCreate(initial, maximum) {
+  // May OOM, but must not fail to validate
+  try {
+      wasmEvalText(`(module
+        (table ${initial} ${maximum || ''} anyfunc)
+      )`);
+  } catch (e) {
+      assertEq(String(e).indexOf("out of memory") !== -1, true, `${e}`);
+  }
+  try {
+    new WebAssembly.Table({
+      initial,
+      maximum,
+      element: 'anyfunc',
+    });
+  } catch (e) {
+    assertEq(String(e).indexOf("out of memory") !== -1, true, `${e}`);
+  }
+}
+
+testTableCreate(0, undefined);
+testTableCreate(1, undefined);
+testTableCreate(0, 1);
+testTableCreate(1, 1);
+testTableCreate(TableMaxRuntime, undefined);
+testTableCreate(TableMaxRuntime, TableMaxValid);
+
+// Test that a table type cannot be instantiated within a module or constructed
+// with a WebAssembly.Table
+function testTableFailCreate(initial, maximum, pattern) {
+  assertErrorMessage(() => wasmEvalText(`(module
+    (table ${initial} ${maximum || ''} anyfunc)
+  )`), WebAssembly.RuntimeError, pattern);
+  assertErrorMessage(() => new WebAssembly.Table({
+    initial,
+    maximum,
+    element: 'anyfunc',
+  }), WebAssembly.RuntimeError, pattern);
+}
+
+testTableFailCreate(TableMaxRuntime + 1, undefined, /too many table elements/);
+testTableFailCreate(TableMaxRuntime + 1, TableMaxValid, /too many table elements/);
+
+// Test that a table type cannot be grown from initial to a target due to an
+// implementation limit
+function testTableFailGrow(initial, maximum, target) {
+  let {run} = wasmEvalText(`(module
+    (table ${initial} ${maximum || ''} externref)
+    (func (export "run") (result i32)
+      ref.null extern
+      i32.const ${target - initial}
+      table.grow
+    )
+  )`).exports;
+  assertEq(run(), -1, 'failed to grow');
+
+  let tab = new WebAssembly.Table({
+    initial,
+    maximum,
+    element: 'externref',
+  });
+  assertErrorMessage(() => tab.grow(target - initial), RangeError, /failed to grow table/);
+}
+
+testTableFailGrow(1, undefined, TableMaxRuntime + 1);
+testTableFailGrow(1, TableMaxValid, TableMaxRuntime + 1);
diff --git a/js/src/jit-test/tests/wasm/memory-aliasing.js b/js/src/jit-test/tests/wasm/memory-aliasing.js
new file mode 100644
index 0000000000..4d76c9eb16
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-aliasing.js
@@ -0,0 +1,24 @@
+var i = wasmEvalText(
+`(module
+   (memory 1) (data (i32.const 0) "\\01\\02\\03\\04\\05\\06\\07\\08")
+   (func $off1 (param $base i32) (result i32)
+     (i32.add
+       (i32.load8_u (local.get $base))
+       (i32.load8_u offset=1 (local.get $base)))
+   )
+   (export "off1" (func $off1))
+   (func $off2 (param $base i32) (result i32)
+     (i32.add
+       (i32.load8_u offset=1 (local.get $base))
+       (i32.load8_u offset=2 (local.get $base)))
+   )
+   (export "off2" (func $off2))
+)`).exports;
+assertEq(i.off1(0), 3);
+assertEq(i.off1(1), 5);
+assertEq(i.off1(2), 7);
+assertEq(i.off1(3), 9);
+assertEq(i.off2(0), 5);
+assertEq(i.off2(1), 7);
+assertEq(i.off2(2), 9);
+assertEq(i.off2(3), 11);
diff --git a/js/src/jit-test/tests/wasm/memory-arm64-ion-codegen.js b/js/src/jit-test/tests/wasm/memory-arm64-ion-codegen.js
new file mode 100644
index 0000000000..48ad75aa11
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-arm64-ion-codegen.js
@@ -0,0 +1,56 @@
+// |jit-test| skip-if: !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().arm64; include:codegen-arm64-test.js
+
+// Test that loads/stores at friendly constant offsets yield expected code
+
+codegenTestARM64_adhoc(
+    `(module
+       (memory 1)
+       (func (export "f") (result i32)
+         (i32.load (i32.const 4000))))`,
+    'f',
+    'b94fa2a0  ldr  w0, \\[x21, #4000\\]');
+
+codegenTestARM64_adhoc(
+    `(module
+       (memory 1)
+       (func (export "f") (result i32)
+         (i32.load offset=1000 (i32.const 3000))))`,
+    'f',
+    'b94fa2a0  ldr  w0, \\[x21, #4000\\]');
+
+codegenTestARM64_adhoc(
+    `(module
+       (memory 1)
+       (func (export "f") (param i32)
+         (i32.store (i32.const 4000) (local.get 0))))`,
+    'f',
+    'b90fa2a0  str w0, \\[x21, #4000\\]');
+
+codegenTestARM64_adhoc(
+    `(module
+       (memory 1)
+       (func (export "f") (param i32)
+         (i32.store offset=1000 (i32.const 3000) (local.get 0))))`,
+    'f',
+    'b90fa2a0  str w0, \\[x21, #4000\\]');
+
+// Unfriendly offsets are first loaded into a scratch register
+
+codegenTestARM64_adhoc(
+    `(module
+       (memory 1)
+       (func (export "f") (result i32)
+         (i32.load (i32.const 4001))))`,
+    'f',
+    `d281f430  mov     x16, #0xfa1
+     b8706aa0  ldr     w0, \\[x21, x16\\]`);
+
+codegenTestARM64_adhoc(
+    `(module
+       (memory 1)
+       (func (export "f") (param i32)
+         (i32.store (i32.const 4001) (local.get 0))))`,
+    'f',
+    `d281f430  mov     x16, #0xfa1
+     b8306aa0  str     w0, \\[x21, x16\\]`);
+
diff --git a/js/src/jit-test/tests/wasm/memory-cloning.js b/js/src/jit-test/tests/wasm/memory-cloning.js
new file mode 100644
index 0000000000..12b05e4aab
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-cloning.js
@@ -0,0 +1,103 @@
+// |jit-test| skip-if: !wasmThreadsEnabled()
+
+// Basic structured cloning tests (specific to SpiderMonkey shell)
+
+var memtypes = wasmMemory64Enabled() ? ['i32', 'i64'] : [''];
+
+function makeMemoryDesc(memtype, d) {
+    if (memtype != '') {
+        d.index = memtype;
+    }
+    return d;
+}
+
+function Zero(memtype) {
+    return memtype == 'i64' ? 0n : 0;
+}
+
+// Should *not* be possible to serialize and deserialize memories that are not
+// shared, whether we transfer them or not.
+
+for ( let memtype of memtypes ) {
+    let mem1 = new WebAssembly.Memory(makeMemoryDesc(memtype, {initial: 2, maximum: 4}));
+    assertErrorMessage(() => serialize(mem1),
+		       TypeError,
+		       /unsupported type for structured data/);
+    assertErrorMessage(() => serialize(mem1, [mem1]),
+		       TypeError,
+		       /invalid transferable array for structured clone/);
+}
+
+// Should be possible to serialize and deserialize memories that are shared, and
+// observe shared effects.
+
+for ( let memtype of memtypes ) {
+    let ptrtype = memtype == 'i64' ? memtype : 'i32';
+    let mem1 = new WebAssembly.Memory(makeMemoryDesc(memtype, {initial: 2, maximum: 4, shared: true}));
+    let buf1 = mem1.buffer;
+
+    // Serialization and deserialization of shared memories work:
+
+    let mem2 = deserialize(serialize(mem1, [], {SharedArrayBuffer: 'allow'}), {SharedArrayBuffer: 'allow'});
+    assertEq(mem2 instanceof WebAssembly.Memory, true);
+    let buf2 = mem2.buffer;
+    assertEq(buf2 instanceof SharedArrayBuffer, true);
+
+    assertEq(buf1 !== buf2, true);
+    assertEq(buf1.byteLength, buf2.byteLength);
+    if (memtype != '' && mem2.type) {
+        assertEq(mem2.type().index, memtype);
+    }
+
+    // Effects to one buffer must be reflected in the other:
+
+    let v1 = new Int32Array(buf1);
+    let v2 = new Int32Array(buf2);
+
+    v1[37] = 0x12345678;
+    assertEq(v2[37], 0x12345678);
+
+    // Growth in a memory is reflected in its clone:
+
+    let index = 2*65536 + 200;
+    let access = wasmEvalText(`(module
+				(memory (import "" "memory") ${memtype} 2 4 shared)
+				(func (export "l") (result ${ptrtype})
+				 (${ptrtype}.load (${ptrtype}.const ${index}))))`,
+			      {"": {memory: mem2}}).exports.l;
+
+    // initially mem2 cannot be accessed at index
+    assertErrorMessage(access, WebAssembly.RuntimeError, /out of bounds/);
+
+    // then we grow mem1
+    wasmEvalText(`(module
+		   (memory (import "" "memory") ${memtype} 2 4 shared)
+		   (func (export "g") (drop (memory.grow (${ptrtype}.const 1)))))`,
+		 {"": {memory: mem1}}).exports.g();
+
+    // after growing mem1, mem2 can be accessed at index
+    assertEq(access(), Zero(memtype));
+}
+
+// Should not be possible to transfer a shared memory
+
+for ( let memtype of memtypes ) {
+    let mem1 = new WebAssembly.Memory(makeMemoryDesc(memtype, {initial: 2, maximum: 4, shared: true}));
+    assertErrorMessage(() => serialize(mem1, [mem1]),
+		       TypeError,
+		       /Shared memory objects must not be in the transfer list/);
+
+}
+
+// When serializing and deserializing a SAB extracted from a memory, the length
+// of the SAB should not change even if the memory was grown after serialization
+// and before deserialization.
+
+for ( let memtype of memtypes ) {
+    let mem = new WebAssembly.Memory(makeMemoryDesc(memtype, {initial: 2, maximum: 4, shared: true}));
+    let buf = mem.buffer;
+    let clonedbuf = serialize(buf, [], {SharedArrayBuffer: 'allow'});
+    mem.grow(1);
+    let buf2 = deserialize(clonedbuf, {SharedArrayBuffer: 'allow'});
+    assertEq(buf.byteLength, buf2.byteLength);
+}
diff --git a/js/src/jit-test/tests/wasm/memory-control/directives.txt b/js/src/jit-test/tests/wasm/memory-control/directives.txt
new file mode 100644
index 0000000000..1092e20d8a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-control/directives.txt
@@ -0,0 +1 @@
+|jit-test| include:wasm.js; test-also=--wasm-compiler=optimizing --wasm-memory-control; test-also=--wasm-compiler=baseline --wasm-memory-control; test-also=--wasm-compiler=optimizing --no-wasm-memory64 --wasm-memory-control; test-also=--wasm-compiler=baseline --no-wasm-memory64 --wasm-memory-control
diff --git a/js/src/jit-test/tests/wasm/memory-control/disabled.js b/js/src/jit-test/tests/wasm/memory-control/disabled.js
new file mode 100644
index 0000000000..48903521db
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-control/disabled.js
@@ -0,0 +1,18 @@
+// |jit-test| skip-if: wasmMemoryControlEnabled()
+
+const { validate } = WebAssembly;
+
+const UNRECOGNIZED_OPCODE = /unrecognized opcode/;
+
+let simpleTests = [
+    "(module (func (memory.discard (i32.const 0) (i32.const 65536))))",
+];
+
+for (let src of simpleTests) {
+    let bin = wasmTextToBinary(src);
+    assertEq(validate(bin), false);
+    wasmCompilationShouldFail(bin, UNRECOGNIZED_OPCODE);
+}
+
+const mem = new WebAssembly.Memory({ initial: 1 });
+assertEq(mem.discard, undefined);
diff --git a/js/src/jit-test/tests/wasm/memory-control/memory-discard.js b/js/src/jit-test/tests/wasm/memory-control/memory-discard.js
new file mode 100644
index 0000000000..87f2ae625a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-control/memory-discard.js
@@ -0,0 +1,227 @@
+// |jit-test| skip-if: !wasmMemoryControlEnabled(); test-also=--wasm-memory64; test-also=--no-wasm-memory64
+
+// This tests memory.discard and WebAssembly.Memory.discard() by placing data
+// (the alphabet) halfway across a page boundary, then discarding the first
+// page. The first half of the alphabet should be zeroed; the second should
+// not. The memory should remain readable and writable.
+//
+// The ultimate goal is to release physical pages of memory back to the
+// operating system, but we can't really observe memory metrics here. Oh well.
+
+function initModule(discardOffset, discardLen, discardViaJS, shared, memType = 'i32') {
+    const memProps = shared ? '4 4 shared' : '4'; // 4 pages
+    const text = `(module
+        (memory (export "memory") ${memType} ${memProps})
+        (data "abcdefghijklmnopqrstuvwxyz")
+        (func (export "init")
+            ;; splat alphabet halfway across the 3/4 page boundary.
+            ;; 196595 = (65536 * 3) - (26 / 2)
+            (memory.init 0 (${memType}.const 196595) (i32.const 0) (i32.const 26))
+        )
+        (func (export "letter") (param i32) (result i32)
+            (i32.load8_u (${memType}.add (${memType}.const 196595) ${memType == 'i64' ? '(i64.extend_i32_u (local.get 0))' : '(local.get 0)'}))
+        )
+        (func (export "discard")
+            (memory.discard (${memType}.const ${discardOffset}) (${memType}.const ${discardLen}))
+        )
+    )`;
+    const exp = wasmEvalText(text).exports;
+
+    return [exp, discardViaJS ? () => exp.memory.discard(discardOffset, discardLen) : exp.discard];
+}
+
+function checkRegion(exp, min, max, expectLetters) {
+    for (let i = min; i < max; i++) {
+        const c = "a".charCodeAt(0) + i;
+        const expected = expectLetters ? c : 0;
+        assertEq(exp.letter(i), expected, `checking position of letter ${String.fromCharCode(c)}`);
+    }
+}
+function checkFirstHalf(exp, expectLetters) { return checkRegion(exp, 0, 13, expectLetters) }
+function checkSecondHalf(exp, expectLetters) { return checkRegion(exp, 13, 26, expectLetters) }
+function checkWholeAlphabet(exp, expectLetters) { return checkRegion(exp, 0, 26, expectLetters) }
+
+function testAll(func) {
+    func(false, false, 'i32');
+    func(false, true, 'i32');
+    func(true, false, 'i32');
+    func(true, true, 'i32');
+    if (wasmMemory64Enabled()) {
+        func(false, false, 'i64');
+        func(false, true, 'i64');
+        func(true, false, 'i64');
+        func(true, true, 'i64');
+    }
+}
+
+testAll(function testHappyPath(discardViaJS, shared, memType) {
+    // Only page 3 of memory, half the alphabet
+    const [exp, discard] = initModule(65536 * 2, 65536, discardViaJS, shared, memType);
+
+    // All zero to start
+    checkWholeAlphabet(exp, false);
+
+    // Then all alphabet
+    exp.init();
+    checkWholeAlphabet(exp, true);
+
+    // Discarding the first page clears the first half of the alphabet
+    discard();
+    checkFirstHalf(exp, false);
+    checkSecondHalf(exp, true);
+
+    // We should be able to write back to a discarded region of memory
+    exp.init();
+    checkWholeAlphabet(exp, true);
+
+    // ...and then discard again
+    discard();
+    checkFirstHalf(exp, false);
+    checkSecondHalf(exp, true);
+});
+
+testAll(function testZeroLen(discardViaJS, shared) {
+    // Discard zero bytes
+    const [exp, discard] = initModule(PageSizeInBytes * 2, 0, discardViaJS, shared);
+
+    // Init the stuff
+    exp.init();
+    checkWholeAlphabet(exp, true);
+
+    // Discarding zero bytes should be valid...
+    discard();
+
+    // ...but should have no effect.
+    checkWholeAlphabet(exp, true);
+});
+
+testAll(function testWithGrow(discardViaJS, shared, memType) {
+    if (shared) {
+        return; // shared memories cannot grow
+    }
+
+    // Only page 3 of memory, half the alphabet. There is no max size on the
+    // memory, so it will be subject to moving grows in 32-bit mode.
+    const [exp, discard] = initModule(65536 * 2, 65536, discardViaJS, false, memType);
+
+    // Start with the whole alphabet
+    exp.init();
+    checkWholeAlphabet(exp, true);
+
+    // Discarding the first page clears the first half of the alphabet
+    discard();
+    checkFirstHalf(exp, false);
+    checkSecondHalf(exp, true);
+
+    // Oops we just grew by a preposterous amount, time to move
+    exp.memory.grow(200)
+
+    // The memory should still be readable
+    checkFirstHalf(exp, false);
+    checkSecondHalf(exp, true);
+
+    // We should be able to write back to a discarded region of memory
+    exp.init();
+    checkWholeAlphabet(exp, true);
+
+    // ...and then discard again
+    discard();
+    checkFirstHalf(exp, false);
+    checkSecondHalf(exp, true);
+});
+
+testAll(function testOOB(discardViaJS, shared) {
+    // Discard two pages where there is only one
+    const [exp, discard] = initModule(PageSizeInBytes * 3, PageSizeInBytes * 2, discardViaJS, shared);
+
+    exp.init();
+    checkWholeAlphabet(exp, true);
+    assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /out of bounds/);
+
+    // Ensure nothing was discarded
+    checkWholeAlphabet(exp, true);
+});
+
+testAll(function testOOB2(discardViaJS, shared) {
+    // Discard two pages starting near the end of 32-bit address space
+    // (would trigger an overflow in 32-bit world)
+    const [exp, discard] = initModule(2 ** 32 - PageSizeInBytes, PageSizeInBytes * 2, discardViaJS, shared);
+
+    exp.init();
+    checkWholeAlphabet(exp, true);
+    assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /out of bounds/);
+
+    // Ensure nothing was discarded
+    checkWholeAlphabet(exp, true);
+});
+
+testAll(function testOOB3(discardViaJS, shared) {
+    // Discard nearly an entire 32-bit address space's worth of pages. Very exciting!
+    const [exp, discard] = initModule(0, 2 ** 32 - PageSizeInBytes, discardViaJS, shared);
+
+    exp.init();
+    checkWholeAlphabet(exp, true);
+    assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /out of bounds/);
+
+    // Ensure nothing was discarded
+    checkWholeAlphabet(exp, true);
+});
+
+(function testOOB4() {
+    // Discard an entire 32-bit address space's worth of pages. JS can do this
+    // even to 32-bit memories because it can handle numbers bigger
+    // than 2^32 - 1.
+    const [exp, _] = initModule(0, 0, false); // pass zero to allow the wasm module to validate
+    const discard = () => exp.memory.discard(0, 2 ** 32);
+
+    exp.init();
+    checkWholeAlphabet(exp, true);
+    assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /out of bounds/);
+
+    // Ensure nothing was discarded
+    checkWholeAlphabet(exp, true);
+})();
+
+if (wasmMemory64Enabled()) {
+    (function testOverflow() {
+        // Discard UINT64_MAX - (2 pages), starting from page 4. This overflows but puts both start and end in bounds.
+        // This cannot be done with a JS discard because JS can't actually represent big enough integers.
+
+        // The big ol' number here is 2^64 - (65536 * 2)
+        const [exp, discard] = initModule(65536 * 3, `18_446_744_073_709_420_544`, false, false, 'i64');
+
+        // Init the stuff
+        exp.init();
+        checkWholeAlphabet(exp, true);
+
+        // Discarding should not be valid when it goes out of bounds
+        assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /out of bounds/);
+
+        // Ensure nothing was discarded
+        checkWholeAlphabet(exp, true);
+    })();
+}
+
+testAll(function testMisalignedStart(discardViaJS, shared) {
+    // Discard only the first half of the alphabet (this misaligns the start)
+    const [exp, discard] = initModule(PageSizeInBytes * 3 - 13, 13, discardViaJS, shared);
+
+    exp.init();
+    checkWholeAlphabet(exp, true);
+    assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /unaligned/);
+
+    // Ensure nothing was discarded
+    checkWholeAlphabet(exp, true);
+});
+
+testAll(function testMisalignedEnd(discardViaJS, shared) {
+    // Discard only the second half of the alphabet (this misaligns the end)
+    const [exp, discard] = initModule(PageSizeInBytes * 3, 13, discardViaJS, shared);
+
+    exp.init();
+    checkWholeAlphabet(exp, true);
+    assertErrorMessage(() => discard(), WebAssembly.RuntimeError, /unaligned/);
+
+    // Ensure nothing was discarded
+    checkWholeAlphabet(exp, true);
+});
diff --git a/js/src/jit-test/tests/wasm/memory-maximum-clamping.js b/js/src/jit-test/tests/wasm/memory-maximum-clamping.js
new file mode 100644
index 0000000000..dfd1d175d7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-maximum-clamping.js
@@ -0,0 +1,32 @@
+const MemoryMaxValid = 65536;
+
+// Linking should fail if the imported memory has a higher maximum than required,
+// however if we internally clamp maximum values to an implementation limit
+// and use that for linking we may erroneously accept some modules.
+
+function testLinkFail(importMax, importedMax) {
+  assertErrorMessage(() => {
+    let importedMemory = new WebAssembly.Memory({
+      initial: 0,
+      maximum: importedMax,
+    });
+    wasmEvalText(`(module
+      (memory (import "" "") 0 ${importMax})
+    )`, {"": {"": importedMemory}});
+  }, WebAssembly.LinkError, /incompatible maximum/);
+}
+
+testLinkFail(0, 1);
+testLinkFail(MemoryMaxValid - 1, MemoryMaxValid);
+
+// The type reflection interface for WebAssembly.Memory should not report
+// an internally clamped maximum.
+
+if ('type' in WebAssembly.Memory.prototype) {
+  let memory = new WebAssembly.Memory({
+    initial: 0,
+    maximum: MemoryMaxValid,
+  });
+  let type = memory.type();
+  assertEq(type.maximum, MemoryMaxValid, 'reported memory maximum is not clamped');
+}
diff --git a/js/src/jit-test/tests/wasm/memory-partial-oob-store.js b/js/src/jit-test/tests/wasm/memory-partial-oob-store.js
new file mode 100644
index 0000000000..d017f8eafb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-partial-oob-store.js
@@ -0,0 +1,129 @@
+// Cloned from memory.js but kept separate because it may have to be disabled on
+// some devices until bugs are fixed.
+
+// Bug 1666747 - partially OOB unaligned stores are not handled correctly on ARM
+// and ARM64.  The simulators don't implement the correct semantics anyhow, so
+// when the bug is fixed in the code generator they must remain excluded here.
+var conf = getBuildConfiguration();
+var excluded = conf.arm64 || conf["arm64-simulator"] || conf.arm || conf["arm-simulator"];
+var thirtytwobit = conf["pointer-byte-size"] == 4;
+
+const RuntimeError = WebAssembly.RuntimeError;
+
+function storeModuleSrc(type, ext, offset, align) {
+    var load_ext = ext === '' ? '' : ext + '_s';
+    return `(module
+       (memory (export "mem") 1)
+       (data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f")
+       (data (i32.const 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func $store (param i32) (param ${type})
+         (${type}.store${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+          (local.get 1)
+         )
+       ) (export "store" (func 0))
+       (func $load (param i32) (result ${type})
+        (${type}.load${load_ext}
+         offset=${offset}
+         ${align != 0 ? 'align=' + align : ''}
+         (local.get 0)
+        )
+       ) (export "load" (func 1)))`;
+}
+
+function storeModule(type, ext, offset, align, exportBox = null) {
+    let exports = wasmEvalText(storeModuleSrc(type, ext, offset, align)).exports;
+    if (exportBox !== null)
+        exportBox.exports = exports;
+    return exports;
+}
+
+function testStoreOOB(type, ext, base, offset, align, value) {
+    let exportBox = {};
+    if (type === 'i64') {
+        assertErrorMessage(() => wasmAssert(
+            storeModuleSrc(type, ext, offset, align),
+            [{type, func: '$store', args: [`i32.const ${base}`, `i64.const ${value}`]}],
+            {},
+            exportBox
+        ), RuntimeError, /index out of bounds/);
+    } else {
+        assertErrorMessage(() => storeModule(type, ext, offset, align, exportBox).store(base, value),
+                           RuntimeError,
+                           /index out of bounds/);
+    }
+
+    // Check that there were no partial writes at the end of the memory.
+    let buf = new Int8Array(exportBox.exports.mem.buffer);
+    let len = buf.length;
+    for ( let addr = base + offset ; addr < len; addr++ )
+        assertEq(buf[addr], 0);
+}
+
+// Test bounds checks and edge cases.
+
+for (let align of [0,1,2,4]) {
+
+    for (let offset of [0, 1, 2, 3, 4, 8, 16, 41, 0xfff0, 0xfff8]) {
+        // Accesses of 1 byte.
+        let lastValidIndex = 0x10000 - 1 - offset;
+        if (align < 2 && !excluded) {
+            testStoreOOB('i32', '8', lastValidIndex + 1, offset, align, -42);
+        }
+
+        // Accesses of 2 bytes.
+        lastValidIndex = 0x10000 - 2 - offset;
+        if (align < 4 && !excluded) {
+            testStoreOOB('i32', '16', lastValidIndex + 1, offset, align, -32768);
+        }
+
+        // Accesses of 4 bytes.
+        lastValidIndex = 0x10000 - 4 - offset;
+        if (!excluded) {
+            testStoreOOB('i32', '', lastValidIndex + 1, offset, align, 1337);
+            testStoreOOB('f32', '', lastValidIndex + 1, offset, align, Math.fround(13.37));
+        }
+
+        // Accesses of 8 bytes.
+        lastValidIndex = 0x10000 - 8 - offset;
+        if (!excluded) {
+            testStoreOOB('f64', '', lastValidIndex + 1, offset, align, 1.23456789);
+        }
+    }
+
+    for (let offset of [0, 1, 2, 3, 4, 8, 16, 41, 0xfff0, 0xfff8]) {
+        // Accesses of 1 byte.
+        let lastValidIndex = 0x10000 - 1 - offset;
+        if (align < 2 && !excluded) {
+            testStoreOOB('i64', '8', lastValidIndex + 1, offset, align, -42);
+        }
+
+        // Accesses of 2 bytes.
+        lastValidIndex = 0x10000 - 2 - offset;
+        if (align < 4 && !excluded) {
+            testStoreOOB('i64', '16', lastValidIndex + 1, offset, align, -32768);
+        }
+
+        // Accesses of 4 bytes.
+        lastValidIndex = 0x10000 - 4 - offset;
+        if (!excluded) {
+            testStoreOOB('i64', '32', lastValidIndex + 1, offset, align, 0xf1231337 | 0);
+        }
+
+        // Accesses of 8 bytes.
+        lastValidIndex = 0x10000 - 8 - offset;
+        if (!excluded) {
+            testStoreOOB('i64', '', lastValidIndex + 1, offset, align, '0x1234567887654321');
+        }
+    }
+}
+
+// On 32-bit platforms, a declared-aligned i64 store is implemented as two
+// presumed-aligned 32-bit stores.  This tests that we don't store the low
+// word before the high word if the low word is in-bounds but the high word
+// is not.
+if (thirtytwobit) {
+    testStoreOOB('i64', '', 0x10000 - 4, 0, 0, '0x0123456789abcdef');
+}
diff --git a/js/src/jit-test/tests/wasm/memory-sharing-off.js b/js/src/jit-test/tests/wasm/memory-sharing-off.js
new file mode 100644
index 0000000000..f3588c98b1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-sharing-off.js
@@ -0,0 +1,23 @@
+// |jit-test| --shared-memory=off; skip-if: !wasmThreadsEnabled()
+
+// A module using shared memory should be convertable from text to binary even
+// if shared memory is disabled.
+
+var bin = wasmTextToBinary('(module (memory 1 1 shared))');
+
+// But we should not be able to validate it:
+
+assertEq(WebAssembly.validate(bin), false);
+
+// Nor to compile it:
+
+assertErrorMessage(() => new WebAssembly.Module(bin),
+		   WebAssembly.CompileError,
+		   /shared memory is disabled/);
+
+// We also should not be able to create a shared memory by itself:
+
+assertErrorMessage(() => new WebAssembly.Memory({initial: 1, maximum: 1, shared: true}),
+		   WebAssembly.LinkError,
+		   /shared memory is disabled/);
+
diff --git a/js/src/jit-test/tests/wasm/memory-sharing.js b/js/src/jit-test/tests/wasm/memory-sharing.js
new file mode 100644
index 0000000000..d67baad4fa
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory-sharing.js
@@ -0,0 +1,210 @@
+// |jit-test| skip-if: !wasmThreadsEnabled()
+
+const WASMPAGE = 65536;
+
+// A shared memory should yield a SharedArrayBuffer of appropriate length
+
+{
+    let mem = new WebAssembly.Memory({initial: 2, maximum: 4, shared: true});
+    assertEq(mem.buffer instanceof SharedArrayBuffer, true);
+    assertEq(mem.buffer.byteLength, WASMPAGE*2);
+}
+
+// Ditto, when the memory was created by instantiation and exported
+
+{
+    let text = `(module
+		 (memory (export "memory") 1 2 shared)
+		 (func (export "l0") (result i32) (i32.load (i32.const 0))))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+    let ins = new WebAssembly.Instance(mod);
+    let mem = ins.exports.memory;
+    let buf = mem.buffer;
+    assertEq(buf instanceof SharedArrayBuffer, true);
+    assertEq(buf.byteLength, WASMPAGE);
+}
+
+// Shared memory requires a maximum size
+
+{
+    assertErrorMessage(() => new WebAssembly.Memory({initial: 2, shared: true}),
+		       TypeError,
+		       /'shared' is true but maximum is not specified/);
+}
+
+// Ditto, syntactically
+
+{
+    let text = `(module
+		 (memory 1 shared)
+		 (func (export "l0") (result i32) (i32.load (i32.const 0))))`;
+    assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(text)),
+		       WebAssembly.CompileError,
+		       /maximum length required for shared memory/);
+}
+
+// Ditto, in the binary.  The flags field can be 0 (unshared, min only), 1
+// (unshared, min and max), or 3 (shared, min and max), but not 2 (shared, min
+// only).  So construct a module that has that, and make sure it's rejected.
+
+{
+    let bin = new Uint8Array([0x00, 0x61, 0x73, 0x6d,
+			      0x01, 0x00, 0x00, 0x00,
+			      0x05,                   // Memory
+			      0x03,                   // Section size
+			      0x01,                   // One memory
+			      0x02,		      // Shared, min only (illegal)
+			      0x01]);		      // Min
+    assertErrorMessage(() => new WebAssembly.Module(bin),
+		       WebAssembly.CompileError,
+		       /maximum length required for shared memory/);
+}
+
+// Importing shared memory and being provided with shared should work
+
+{
+    let text = `(module
+		 (memory (import "" "memory") 1 1 shared)
+		 (func (export "id") (param i32) (result i32) (local.get 0)))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared: true});
+    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+    assertEq(ins.exports.id(0x12345678), 0x12345678);
+}
+
+// Importing shared memory but being provided with unshared should fail
+
+{
+    let text = `(module
+		 (memory (import "" "memory") 1 1 shared)
+		 (func (export "id") (param i32) (result i32) (local.get 0)))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+    let mem = new WebAssembly.Memory({initial: 1, maximum: 1});
+    assertErrorMessage(() => new WebAssembly.Instance(mod, {"": {memory: mem}}),
+		       WebAssembly.LinkError,
+		       /unshared memory but shared required/);
+}
+
+// Importing unshared memory but being provided with shared should fail
+
+{
+    let text = `(module
+		 (memory (import "" "memory") 1 1)
+		 (func (export "id") (param i32) (result i32) (local.get 0)))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+    let mem = new WebAssembly.Memory({initial: 1, maximum: 1, shared: true});
+    assertErrorMessage(() => new WebAssembly.Instance(mod, {"": {memory: mem}}),
+		       WebAssembly.LinkError,
+		       /shared memory but unshared required/);
+}
+
+// Importing shared memory and being provided with shared memory with
+// incompatible parameters should fail
+
+{
+    let text = `(module
+		 (memory (import "" "memory") 2 4 shared)
+		 (func (export "id") (param i32) (result i32) (local.get 0)))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+
+    // some cases that are non-matching are allowed, eg, initial > declared min
+
+    // initial < declared min
+    let mem3 = new WebAssembly.Memory({initial: 1, maximum: 4, shared: true});
+    assertErrorMessage(() => new WebAssembly.Instance(mod, {"": {memory: mem3}}),
+		       WebAssembly.LinkError,
+		       /imported Memory with incompatible size/);
+
+    // initial > declared max
+    let mem4 = new WebAssembly.Memory({initial: 5, maximum: 8, shared: true});
+    assertErrorMessage(() => new WebAssembly.Instance(mod, {"": {memory: mem4}}),
+		       WebAssembly.LinkError,
+		       /imported Memory with incompatible size/);
+
+    // max > declared max
+    let mem5 = new WebAssembly.Memory({initial: 2, maximum: 8, shared: true});
+    assertErrorMessage(() => new WebAssembly.Instance(mod, {"": {memory: mem5}}),
+		       WebAssembly.LinkError,
+		       /imported Memory with incompatible maximum size/);
+}
+
+
+// basic memory.size and memory.grow operation, with bounds checking near the
+// valid/invalid boundary
+
+{
+    let text = `(module
+		 (memory (export "memory") 2 4 shared)
+		 (func (export "c") (result i32) memory.size)
+		 (func (export "g") (result i32) (memory.grow (i32.const 1)))
+		 (func (export "l") (param i32) (result i32) (i32.load (local.get 0)))
+		 (func (export "s") (param i32) (param i32) (i32.store (local.get 0) (local.get 1))))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+    let ins = new WebAssembly.Instance(mod);
+    let exp = ins.exports;
+    let mem = exp.memory;
+
+    let b1 = mem.buffer;
+    assertEq(exp.c(), 2);
+    assertEq(b1.byteLength, WASMPAGE*2);
+    assertEq(mem.buffer === b1, true);   // memory.size does not affect buffer
+    exp.s(WASMPAGE*2-4, 0x12345678)	 // access near end
+    assertEq(exp.l(WASMPAGE*2-4), 0x12345678);
+    assertErrorMessage(() => exp.l(WASMPAGE*2), // beyond current end (but below max)
+		       WebAssembly.RuntimeError,
+		       /index out of bounds/);
+    assertEq(exp.g(), 2);
+    assertEq(b1.byteLength, WASMPAGE*2); // growing does not affect existing buffer length
+    let b2 = mem.buffer;
+    assertEq(b1 !== b2, true);	         // growing produces a new buffer
+    assertEq(b2.byteLength, WASMPAGE*3); // new buffer has appropriate length
+    assertEq(exp.c(), 3);
+    exp.s(WASMPAGE*3-4, 0x12344321);     // access near new end
+    assertEq(exp.l(WASMPAGE*3-4), 0x12344321);
+    assertErrorMessage(() => exp.l(WASMPAGE*3), // beyond current end (but below max)
+		       WebAssembly.RuntimeError,
+		       /index out of bounds/);
+    assertEq(exp.g(), 3);
+    assertEq(b2.byteLength, WASMPAGE*3); // growing does not affect existing buffer length
+    let b3 = mem.buffer;
+    assertEq(b2 !== b3, true);	         // growing produces a new buffer
+    assertEq(b3.byteLength, WASMPAGE*4); // new buffer has appropriate length
+    assertEq(exp.c(), 4);
+    exp.s(WASMPAGE*4-4, 0x12121212);     // access near new end
+    assertEq(exp.l(WASMPAGE*4-4), 0x12121212);
+    assertErrorMessage(() => exp.l(WASMPAGE*4), // beyond current end (and beyond max)
+		       WebAssembly.RuntimeError,
+		       /index out of bounds/);
+    assertEq(exp.g(), -1);
+    assertEq(exp.c(), 4);                // failure to grow -> no change
+    let b4 = mem.buffer;
+    assertEq(b3 === b4, true);	         // failure to grow -> same ol' buffer
+    assertEq(exp.g(), -1);               // we can fail repeatedly
+}
+
+// Test the grow() API with shared memory.  In the implementation this API
+// shares almost all code with the wasm instruction, so don't bother going deep.
+
+{
+    let mem = new WebAssembly.Memory({initial: 2, maximum: 4, shared: true});
+    let buf = mem.buffer;
+    assertEq(mem.grow(1), 2);
+    assertEq(buf.byteLength, WASMPAGE*2);
+    assertEq(mem.grow(1), 3);
+    assertErrorMessage(() => mem.grow(1), RangeError, /failed to grow memory/);
+}
+
+// Initializing shared memory with data
+
+{
+    let text = `(module
+		 (memory (import "" "memory") 2 4 shared)
+		 (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
+		 (func (export "l") (param i32) (result i32) (i32.load8_u (local.get 0))))`;
+    let mod = new WebAssembly.Module(wasmTextToBinary(text));
+    let mem = new WebAssembly.Memory({initial: 2, maximum: 4, shared: true});
+    let ins = new WebAssembly.Instance(mod, {"": {memory: mem}});
+    let exp = ins.exports;
+    assertEq(exp.l(12), "a".charCodeAt(0) + 12);
+}
+
diff --git a/js/src/jit-test/tests/wasm/memory.js b/js/src/jit-test/tests/wasm/memory.js
new file mode 100644
index 0000000000..f5d7bb0a7d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory.js
@@ -0,0 +1,506 @@
+const RuntimeError = WebAssembly.RuntimeError;
+
+function loadModuleSrc(type, ext, offset, align, drop = false) {
+    let maybeResult = drop ? '' : `(result ${type})`;
+    let maybeDrop = drop ? 'drop' : '';
+    return `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func $load (param i32) ${maybeResult}
+         (${type}.load${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+         )
+         ${maybeDrop}
+       ) (export "" (func 0)))`;
+}
+function loadModule(type, ext, offset, align, drop = false) {
+    return wasmEvalText(loadModuleSrc(type, ext, offset, align, drop)).exports[""];
+}
+
+function storeModuleSrc(type, ext, offset, align) {
+    var load_ext = ext === '' ? '' : ext + '_s';
+    return `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func $store (param i32) (param ${type})
+         (${type}.store${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+          (local.get 1)
+         )
+       ) (export "store" (func 0))
+       (func $load (param i32) (result ${type})
+        (${type}.load${load_ext}
+         offset=${offset}
+         ${align != 0 ? 'align=' + align : ''}
+         (local.get 0)
+        )
+       ) (export "load" (func 1)))`;
+}
+function storeModule(type, ext, offset, align) {
+    return wasmEvalText(storeModuleSrc(type, ext, offset, align)).exports;
+}
+
+function storeModuleCstSrc(type, ext, offset, align, value) {
+    var load_ext = ext === '' ? '' : ext + '_s';
+    return `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+       (func $store (param i32)
+         (${type}.store${ext}
+          offset=${offset}
+          ${align != 0 ? 'align=' + align : ''}
+          (local.get 0)
+          (${type}.const ${value})
+         )
+       ) (export "store" (func 0))
+       (func $load (param i32) (result ${type})
+        (${type}.load${load_ext}
+         offset=${offset}
+         ${align != 0 ? 'align=' + align : ''}
+         (local.get 0)
+        )
+       ) (export "load" (func 1)))`;
+}
+function storeModuleCst(type, ext, offset, align, value) {
+    return wasmEvalText(storeModuleCstSrc(type, ext, offset, align, value)).exports;
+}
+
+function testLoad(type, ext, base, offset, align, expect) {
+    if (type === 'i64') {
+        wasmAssert(loadModuleSrc(type, ext, offset, align), [{
+            type,
+            func: '$load',
+            expected: expect,
+            args: [`i32.const ${base}`]
+        }]);
+    }
+    else {
+        assertEq(loadModule(type, ext, offset, align)(base), expect);
+    }
+}
+
+function testLoadOOB(type, ext, base, offset, align) {
+    assertErrorMessage(() => loadModule(type, ext, offset, align, /*drop*/ true)(base), RuntimeError, /index out of bounds/);
+}
+
+function testStore(type, ext, base, offset, align, value) {
+    if (type === 'i64') {
+        wasmAssert(storeModuleSrc(type, ext, offset, align), [
+            {type, func: '$store', args: [`i32.const ${base}`, `i64.const ${value}`]},
+            {type, func: '$load', args: [`i32.const ${base}`], expected: value},
+        ]);
+        wasmAssert(storeModuleCstSrc(type, ext, offset, align, value), [
+            {type, func: '$store', args: [`i32.const ${base}`]},
+            {type, func: '$load', args: [`i32.const ${base}`], expected: value},
+        ]);
+    } else {
+        let module = storeModule(type, ext, offset, align);
+        let moduleCst = storeModuleCst(type, ext, offset, align, value);
+        module.store(base, value);
+        assertEq(module.load(base), value);
+        moduleCst.store(base);
+        assertEq(moduleCst.load(base), value);
+    }
+}
+
+function testStoreOOB(type, ext, base, offset, align, value) {
+    if (type === 'i64') {
+        assertErrorMessage(() => wasmAssert(
+            storeModuleSrc(type, ext, offset, align),
+            [{type, func: '$store', args: [`i32.const ${base}`, `i64.const ${value}`]}]
+        ), RuntimeError, /index out of bounds/);
+    } else {
+        assertErrorMessage(() => storeModule(type, ext, offset, align).store(base, value), RuntimeError, /index out of bounds/);
+    }
+}
+
+function badLoadModule(type, ext) {
+    wasmFailValidateText( `(module (func (param i32) (${type}.load${ext} (local.get 0))) (export "" (func 0)))`, /(can't touch memory)|(unknown memory 0)/);
+}
+
+function badStoreModule(type, ext) {
+    wasmFailValidateText(`(module (func (param i32) (${type}.store${ext} (local.get 0) (${type}.const 0))) (export "" (func 0)))`, /(can't touch memory)|(unknown memory 0)/);
+}
+
+// Can't touch memory.
+for (let [type, ext] of [
+    ['i32', ''],
+    ['i32', '8_s'],
+    ['i32', '8_u'],
+    ['i32', '16_s'],
+    ['i32', '16_u'],
+    ['i64', ''],
+    ['i64', '8_s'],
+    ['i64', '8_u'],
+    ['i64', '16_s'],
+    ['i64', '16_u'],
+    ['i64', '32_s'],
+    ['i64', '32_u'],
+    ['f32', ''],
+    ['f64', ''],
+])
+{
+    badLoadModule(type, ext);
+}
+
+for (let [type, ext] of [
+    ['i32', ''],
+    ['i32', '8'],
+    ['i32', '16'],
+    ['i64', ''],
+    ['i64', '8'],
+    ['i64', '16'],
+    ['i64', '32'],
+    ['f32', ''],
+    ['f64', ''],
+])
+{
+    badStoreModule(type, ext);
+}
+
+assertEq(getJitCompilerOptions()['wasm.fold-offsets'], 1);
+
+for (var foldOffsets = 0; foldOffsets <= 1; foldOffsets++) {
+    setJitCompilerOption('wasm.fold-offsets', foldOffsets | 0);
+
+    testLoad('i32', '', 0, 0, 0, 0x03020100);
+    testLoad('i32', '', 1, 0, 1, 0x04030201);
+    testLoad('i32', '', 0, 4, 0, 0x07060504);
+    testLoad('i32', '', 1, 3, 4, 0x07060504);
+    testLoad('f32', '', 0, 0, 0, 3.820471434542632e-37);
+    testLoad('f32', '', 1, 0, 1, 1.539989614439558e-36);
+    testLoad('f32', '', 0, 4, 0, 1.0082513512365273e-34);
+    testLoad('f32', '', 1, 3, 4, 1.0082513512365273e-34);
+    testLoad('f64', '', 0, 0, 0, 7.949928895127363e-275);
+    testLoad('f64', '', 1, 0, 1, 5.447603722011605e-270);
+    testLoad('f64', '', 0, 8, 0, 3.6919162048650923e-236);
+    testLoad('f64', '', 1, 7, 8, 3.6919162048650923e-236);
+
+    testLoad('i32', '8_s', 16, 0, 0, -0x10);
+    testLoad('i32', '8_u', 16, 0, 0, 0xf0);
+    testLoad('i32', '16_s', 16, 0, 0, -0xe10);
+    testLoad('i32', '16_u', 16, 0, 0, 0xf1f0);
+
+    testStore('i32', '', 0, 0, 0, -0x3f3e2c2c);
+    testStore('i32', '', 1, 0, 1, -0x3f3e2c2c);
+    testStore('i32', '', 0, 1, 1, -0x3f3e2c2c);
+    testStore('i32', '', 1, 1, 4, -0x3f3e2c2c);
+
+    testStore('f32', '', 0, 0, 0, 0.01234566979110241);
+    testStore('f32', '', 1, 0, 1, 0.01234566979110241);
+    testStore('f32', '', 0, 4, 0, 0.01234566979110241);
+    testStore('f32', '', 1, 3, 4, 0.01234566979110241);
+    testStore('f64', '', 0, 0, 0, 0.89012345);
+    testStore('f64', '', 1, 0, 1, 0.89012345);
+    testStore('f64', '', 0, 8, 0, 0.89012345);
+    testStore('f64', '', 1, 7, 8, 0.89012345);
+
+    testStore('i32', '8', 0, 0, 0, 0x23);
+    testStore('i32', '16', 0, 0, 0, 0x2345);
+
+    wasmFailValidateText('(module (memory 2 1))', /maximum length 1 is less than initial length 2/);
+
+    // Test bounds checks and edge cases.
+
+    for (let align of [0,1,2,4]) {
+
+        for (let offset of [0, 1, 2, 3, 4, 8, 16, 41, 0xfff8]) {
+            // Accesses of 1 byte.
+            let lastValidIndex = 0x10000 - 1 - offset;
+
+            if (align < 2) {
+                testLoad('i32', '8_s', lastValidIndex, offset, align, 0);
+                testLoadOOB('i32', '8_s', lastValidIndex + 1, offset, align);
+
+                testLoad('i32', '8_u', lastValidIndex, offset, align, 0);
+                testLoadOOB('i32', '8_u', lastValidIndex + 1, offset, align);
+
+                testStore('i32', '8', lastValidIndex, offset, align, -42);
+                testStoreOOB('i32', '8', lastValidIndex + 1, offset, align, -42);
+            }
+
+            // Accesses of 2 bytes.
+            lastValidIndex = 0x10000 - 2 - offset;
+
+            if (align < 4) {
+                testLoad('i32', '16_s', lastValidIndex, offset, align, 0);
+                testLoadOOB('i32', '16_s', lastValidIndex + 1, offset, align);
+
+                testLoad('i32', '16_u', lastValidIndex, offset, align, 0);
+                testLoadOOB('i32', '16_u', lastValidIndex + 1, offset, align);
+
+                testStore('i32', '16', lastValidIndex, offset, align, -32768);
+                testStoreOOB('i32', '16', lastValidIndex + 1, offset, align, -32768);
+            }
+
+            // Accesses of 4 bytes.
+            lastValidIndex = 0x10000 - 4 - offset;
+
+            testLoad('i32', '', lastValidIndex, offset, align, 0);
+            testLoadOOB('i32', '', lastValidIndex + 1, offset, align);
+
+            testLoad('f32', '', lastValidIndex, offset, align, 0);
+            testLoadOOB('f32', '', lastValidIndex + 1, offset, align);
+
+            testStore('i32', '', lastValidIndex, offset, align, 1337);
+            testStoreOOB('i32', '', lastValidIndex + 1, offset, align, 1337);
+
+            testStore('f32', '', lastValidIndex, offset, align, Math.fround(13.37));
+            testStoreOOB('f32', '', lastValidIndex + 1, offset, align, Math.fround(13.37));
+
+            // Accesses of 8 bytes.
+            lastValidIndex = 0x10000 - 8 - offset;
+
+            testLoad('f64', '', lastValidIndex, offset, align, 0);
+            testLoadOOB('f64', '', lastValidIndex + 1, offset, align);
+
+            testStore('f64', '', lastValidIndex, offset, align, 1.23456789);
+            testStoreOOB('f64', '', lastValidIndex + 1, offset, align, 1.23456789);
+        }
+
+        // Ensure wrapping doesn't apply.
+        offset = 0x7fffffff;
+        for (let index of [0, 1, 2, 3, 0x7fffffff, 0x80000000, 0x80000001]) {
+            if (align < 2) {
+                testLoadOOB('i32', '8_s', index, offset, align);
+            }
+            if (align < 4) {
+                testLoadOOB('i32', '16_s', index, offset, align);
+            }
+            testLoadOOB('i32', '', index, offset, align);
+            testLoadOOB('f32', '', index, offset, align);
+            testLoadOOB('f64', '', index, offset, align);
+        }
+
+        // Ensure out of bounds when the offset is greater than the immediate range.
+        index = 0;
+        for (let offset of [0x80000000, 0xfffffffe, 0xffffffff]) {
+            testLoadOOB('i32', '8_s', index, offset, 1);
+            testLoadOOB('i32', '16_s', index, offset, 1);
+            testLoadOOB('i32', '16_s', index, offset, 2);
+            testLoadOOB('i32', '', index, offset, 1);
+            testLoadOOB('i32', '', index, offset, 4);
+            testLoadOOB('f32', '', index, offset, 1);
+            testLoadOOB('f32', '', index, offset, 4);
+            testLoadOOB('f64', '', index, offset, 1);
+            testLoadOOB('f64', '', index, offset, 8);
+        }
+
+        wasmFailValidateText('(module (memory 1) (func (f64.store offset=0 (i32.const 0) (i32.const 0))))', mismatchError("i32", "f64"));
+        wasmFailValidateText('(module (memory 1) (func (f64.store offset=0 (i32.const 0) (f32.const 0))))', mismatchError("f32", "f64"));
+
+        wasmFailValidateText('(module (memory 1) (func (f32.store offset=0 (i32.const 0) (i32.const 0))))', mismatchError("i32", "f32"));
+        wasmFailValidateText('(module (memory 1) (func (f32.store offset=0 (i32.const 0) (f64.const 0))))', mismatchError("f64", "f32"));
+
+        wasmFailValidateText('(module (memory 1) (func (i32.store offset=0 (i32.const 0) (f32.const 0))))', mismatchError("f32", "i32"));
+        wasmFailValidateText('(module (memory 1) (func (i32.store offset=0 (i32.const 0) (f64.const 0))))', mismatchError("f64", "i32"));
+
+        // Test high number of registers.
+        function testRegisters() {
+            assertEq(wasmEvalText(
+                `(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 16) "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff")
+              (func (param i32) (result i32) (local i32 i32 i32 i32 f32 f64)
+               (local.set 1 (i32.load8_s offset=4 (local.get 0)))
+               (local.set 2 (i32.load16_s (local.get 1)))
+               (i32.store8 offset=4 (local.get 0) (local.get 1))
+               (local.set 3 (i32.load16_u (local.get 2)))
+               (i32.store16 (local.get 1) (local.get 2))
+               (local.set 4 (i32.load (local.get 2)))
+               (i32.store (local.get 1) (local.get 2))
+               (local.set 5 (f32.load (local.get 4)))
+               (f32.store (local.get 4) (local.get 5))
+               (local.set 6 (f64.load (local.get 4)))
+               (f64.store (local.get 4) (local.get 6))
+               (i32.add
+                (i32.add
+                 (local.get 0)
+                 (local.get 1)
+                )
+                (i32.add
+                 (i32.add
+                  (local.get 2)
+                  (local.get 3)
+                 )
+                 (i32.add
+                  (local.get 4)
+                  (i32.reinterpret/f32 (local.get 5))
+                 )
+                )
+               )
+              ) (export "" (func 0)))`
+            ).exports[""](1), 50464523);
+        }
+
+        testRegisters();
+
+        testLoad('i64', '', 0, 0, 0, '0x0706050403020100');
+        testLoad('i64', '', 1, 0, 0, '0x0807060504030201');
+        testLoad('i64', '', 0, 1, 0, '0x0807060504030201');
+        testLoad('i64', '', 1, 1, 4, '0x0908070605040302');
+
+        testLoad('i64', '8_s', 16, 0, 0, -0x10);
+        testLoad('i64', '8_u', 16, 0, 0, 0xf0);
+        testLoad('i64', '16_s', 16, 0, 0, -0xe10);
+        testLoad('i64', '16_u', 16, 0, 0, 0xf1f0);
+        testLoad('i64', '32_s', 16, 0, 0, 0xf3f2f1f0 | 0);
+        testLoad('i64', '32_u', 16, 0, 0, '0xf3f2f1f0');
+
+        testStore('i64', '', 0, 0, 0, '0xc0c1d3d4e6e7090a');
+        testStore('i64', '', 1, 0, 0, '0xc0c1d3d4e6e7090a');
+        testStore('i64', '', 0, 1, 0, '0xc0c1d3d4e6e7090a');
+        testStore('i64', '', 1, 1, 4, '0xc0c1d3d4e6e7090a');
+        testStore('i64', '8', 0, 0, 0, 0x23);
+        testStore('i64', '16', 0, 0, 0, 0x23);
+        testStore('i64', '32', 0, 0, 0, 0x23);
+
+        for (let offset of [0, 1, 2, 3, 4, 8, 16, 41, 0xfff8]) {
+            // Accesses of 1 byte.
+            let lastValidIndex = 0x10000 - 1 - offset;
+
+            if (align < 2) {
+                testLoad('i64', '8_s', lastValidIndex, offset, align, 0);
+                testLoadOOB('i64', '8_s', lastValidIndex + 1, offset, align);
+
+                testLoad('i64', '8_u', lastValidIndex, offset, align, 0);
+                testLoadOOB('i64', '8_u', lastValidIndex + 1, offset, align);
+
+                testStore('i64', '8', lastValidIndex, offset, align, -42);
+                testStoreOOB('i64', '8', lastValidIndex + 1, offset, align, -42);
+            }
+
+            // Accesses of 2 bytes.
+            lastValidIndex = 0x10000 - 2 - offset;
+
+            if (align < 4) {
+                testLoad('i64', '16_s', lastValidIndex, offset, align, 0);
+                testLoadOOB('i64', '16_s', lastValidIndex + 1, offset, align);
+
+                testLoad('i64', '16_u', lastValidIndex, offset, align, 0);
+                testLoadOOB('i64', '16_u', lastValidIndex + 1, offset, align);
+
+                testStore('i64', '16', lastValidIndex, offset, align, -32768);
+                testStoreOOB('i64', '16', lastValidIndex + 1, offset, align, -32768);
+            }
+
+            // Accesses of 4 bytes.
+            lastValidIndex = 0x10000 - 4 - offset;
+
+            testLoad('i64', '32_s', lastValidIndex, offset, align, 0);
+            testLoadOOB('i64', '32_s', lastValidIndex + 1, offset, align);
+
+            testLoad('i64', '32_u', lastValidIndex, offset, align, 0);
+            testLoadOOB('i64', '32_u', lastValidIndex + 1, offset, align);
+
+            testStore('i64', '32', lastValidIndex, offset, align, 0xf1231337 | 0);
+            testStoreOOB('i64', '32', lastValidIndex + 1, offset, align, 0xf1231337 | 0);
+
+            // Accesses of 8 bytes.
+            lastValidIndex = 0x10000 - 8 - offset;
+
+            testLoad('i64', '', lastValidIndex, offset, align, 0);
+            testLoadOOB('i64', '', lastValidIndex + 1, offset, align);
+
+            testStore('i64', '', lastValidIndex, offset, align, '0x1234567887654321');
+            testStoreOOB('i64', '', lastValidIndex + 1, offset, align, '0x1234567887654321');
+        }
+    }
+}
+
+setJitCompilerOption('wasm.fold-offsets', 1);
+
+// Test active segments with a memory index.
+
+{
+    function makeIt(flag, memindex) {
+        return new Uint8Array([0x00, 0x61, 0x73, 0x6d,
+                               0x01, 0x00, 0x00, 0x00,
+                               0x05,                   // Memory section
+                               0x03,                   // Section size
+                               0x01,                   // One memory
+                               0x00,                   // Unshared, min only
+                               0x01,                   // Min
+                               0x0b,                   // Data section
+                               0x0a,                   // Section size
+                               0x01,                   // One data segment
+                               flag,                   // Flag should be 2, or > 2 if invalid
+                               memindex,               // Memory index should be 0, or > 0 if invalid
+                               0x41,                   // Init expr: i32.const
+                               0x00,                   // Init expr: zero (payload)
+                               0x0b,                   // Init expr: end
+                               0x03,                   // Three bytes, because why not?
+                               0x01,
+                               0x02,
+                               0x03]);
+    }
+
+    // Should succeed because this is what an active segment with index looks like
+    new WebAssembly.Module(makeIt(0x02, 0x00));
+
+    // Should fail because the kind is unknown
+    assertErrorMessage(() => new WebAssembly.Module(makeIt(0x03, 0x00)),
+                       WebAssembly.CompileError,
+                       /invalid data initializer-kind/);
+
+    // Should fail because the memory index is bad
+    assertErrorMessage(() => new WebAssembly.Module(makeIt(0x02, 0x01)),
+                       WebAssembly.CompileError,
+                       /memory index must be zero/);
+}
+
+// Misc syntax for data.
+
+// When memory index is present it must be zero, and the offset must be present too;
+// but it's OK for there to be neither
+new WebAssembly.Module(wasmTextToBinary(`(module (memory 1) (data 0 (i32.const 0) ""))`));
+new WebAssembly.Module(wasmTextToBinary(`(module (memory 1) (data 0 (offset (i32.const 0)) ""))`));
+new WebAssembly.Module(wasmTextToBinary(`(module (memory 1) (data ""))`));
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`(module (memory 1) (data 0 ""))`)),
+                   SyntaxError,
+                   /wasm text error/);
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`(module (memory 1) (data 1 (i32.const 0) ""))`)),
+                   WebAssembly.CompileError,
+                   /memory index must be zero/);
+
+
+// Make sure we handle memory instructions without memory
+
+var nomem = /(can't touch memory without memory)|(unknown memory)/;
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`(module (func (result i32) memory.size))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`(module (func (result i32) (memory.grow (i32.const 1))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module (func (param i32 i32 i32)
+  (memory.copy (local.get 0) (local.get 1) (local.get 2))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module (func (param i32 i32 i32)
+  (memory.fill (local.get 0) (local.get 1) (local.get 2))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (data $d "01234")
+  (func (param i32 i32)
+    (memory.init $d (local.get 0) (local.get 1))))`)),
+                   WebAssembly.CompileError,
+                   nomem);
+
diff --git a/js/src/jit-test/tests/wasm/memory64/basic.js b/js/src/jit-test/tests/wasm/memory64/basic.js
new file mode 100644
index 0000000000..bf40707b9f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/basic.js
@@ -0,0 +1,1575 @@
+// |jit-test| allow-oom
+
+// Basic tests around creating and linking memories with i64 indices
+
+const MaxMemory64Field = 0x1_0000_0000_0000; // pages
+const MaxUint32 = 0xFFFF_FFFF;
+
+// test the validity of different i64 memory types in validation, compilation,
+// and the JS-API.
+function memoryTypeModuleText(shared, initial, max) {
+  return `(module
+            (memory i64 ${initial} ${max !== undefined ? max : ''} ${shared ? `shared` : ''}))`;
+}
+function memoryTypeDescriptor(shared, initial, max) {
+  return {
+    // TODO: "index" is not yet part of the spec
+    // https://github.com/WebAssembly/memory64/issues/24
+    index: 'i64',
+    initial,
+    maximum: max,
+    shared,
+  };
+}
+function validMemoryType(shared, initial, max) {
+  wasmValidateText(memoryTypeModuleText(shared, initial, max));
+  wasmEvalText(memoryTypeModuleText(shared, initial, max));
+  // TODO: JS-API cannot specify pages above UINT32_MAX
+  // https://github.com/WebAssembly/memory64/issues/24
+  new WebAssembly.Memory(memoryTypeDescriptor(shared, initial, max));
+}
+function invalidMemoryType(shared, initial, max, compileMessage, jsMessage) {
+  wasmFailValidateText(memoryTypeModuleText(shared, initial, max), compileMessage);
+  assertErrorMessage(() => wasmEvalText(memoryTypeModuleText(shared, initial, max)), WebAssembly.CompileError, compileMessage);
+  // TODO: JS-API cannot specify pages above UINT32_MAX
+  // https://github.com/WebAssembly/memory64/issues/24
+  assertErrorMessage(() => new WebAssembly.Memory(memoryTypeDescriptor(shared, initial, max)), Error, jsMessage);
+}
+
+// valid to define a memory with i64
+validMemoryType(false, 0);
+// valid to define max with i64
+validMemoryType(false, 0, 1);
+// invalid for min to be greater than max with i64
+invalidMemoryType(false, 2, 1, /minimum must not be greater than maximum/, /bad Memory maximum size/);
+// valid to define shared memory with max with i64
+validMemoryType(true, 1, 2);
+// invalid to define shared memory without max with i64
+invalidMemoryType(true, 1, undefined, /maximum length required for shared memory/, /maximum is not specified/);
+
+// test the limits of memory64
+validMemoryType(false, 0, MaxMemory64Field);
+invalidMemoryType(false, 0, MaxMemory64Field + 1, /maximum memory size too big/, /bad Memory maximum/);
+validMemoryType(true, 0, MaxMemory64Field);
+invalidMemoryType(true, 0, MaxMemory64Field + 1, /maximum memory size too big/, /bad Memory maximum/);
+
+// test that linking requires index types to be equal
+function testLink(importedIndexType, importIndexType) {
+  let imported = new WebAssembly.Memory({
+    // TODO: "index" is not yet part of the spec
+    // https://github.com/WebAssembly/memory64/issues/24
+    index: importedIndexType,
+    initial: 0,
+  });
+  let testModule =
+      `(module
+         (memory (import "" "imported") ${importIndexType} 0))`;
+  if (importedIndexType === importIndexType) {
+    wasmEvalText(testModule, {"": {imported}});
+  } else {
+    assertErrorMessage(() => wasmEvalText(testModule, {"": {imported}}), WebAssembly.LinkError, /index type/);
+  }
+}
+
+var memTypes = [
+    ['i64', 'i64'],
+    ['i32', 'i32'],
+    ['i64', 'i32'],
+    ['i32', 'i64']];
+
+for ( let [a,b] of memTypes ) {
+    testLink(a, b);
+}
+
+// Active data segments use the index type for the init expression
+
+for ( let [memType,exprType] of memTypes ) {
+    assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory ${memType} 1)
+  (data (${exprType}.const 0) "abcde"))`)), memType == exprType);
+}
+
+// Validate instructions using 32/64-bit pointers in 32/64-bit memories.
+
+var validOffsets = {i32: ['', 'offset=0x10000000'],
+                    i64: ['', 'offset=0x10000000', 'offset=0x200000000']}
+
+// Basic load/store
+for (let [memType, ptrType] of memTypes ) {
+    for (let offs of validOffsets[memType]) {
+        assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory ${memType} 1)
+  (func (param $p ${ptrType}) (param $i i32) (param $l i64) (param $f f32) (param $d f64)
+    (drop (i32.add (i32.const 1) (i32.load8_s ${offs} (local.get $p))))
+    (drop (i32.add (i32.const 1) (i32.load8_u ${offs} (local.get $p))))
+    (drop (i32.add (i32.const 1) (i32.load16_s ${offs} (local.get $p))))
+    (drop (i32.add (i32.const 1) (i32.load16_u ${offs} (local.get $p))))
+    (drop (i32.add (i32.const 1) (i32.load ${offs} (local.get $p))))
+    (i32.store8 ${offs} (local.get $p) (local.get $i))
+    (i32.store16 ${offs} (local.get $p) (local.get $i))
+    (i32.store ${offs} (local.get $p) (local.get $i))
+    (drop (i64.add (i64.const 1) (i64.load8_s ${offs} (local.get $p))))
+    (drop (i64.add (i64.const 1) (i64.load8_u ${offs} (local.get $p))))
+    (drop (i64.add (i64.const 1) (i64.load16_s ${offs} (local.get $p))))
+    (drop (i64.add (i64.const 1) (i64.load16_u ${offs} (local.get $p))))
+    (drop (i64.add (i64.const 1) (i64.load32_s ${offs} (local.get $p))))
+    (drop (i64.add (i64.const 1) (i64.load32_u ${offs} (local.get $p))))
+    (drop (i64.add (i64.const 1) (i64.load ${offs} (local.get $p))))
+    (i64.store8 ${offs} (local.get $p) (local.get $l))
+    (i64.store16 ${offs} (local.get $p) (local.get $l))
+    (i64.store32 ${offs} (local.get $p) (local.get $l))
+    (i64.store ${offs} (local.get $p) (local.get $l))
+    (drop (f32.add (f32.const 1) (f32.load ${offs} (local.get $p))))
+    (f32.store ${offs} (local.get $p) (local.get $f))
+    (drop (f64.add (f64.const 1) (f64.load ${offs} (local.get $p))))
+    (f64.store ${offs} (local.get $p) (local.get $d))
+))`)), memType == ptrType);
+    }
+}
+
+// Bulk memory operations
+for (let [memType, ptrType] of memTypes ) {
+    assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory ${memType} 1)
+  (data $seg "0123456789abcdef")
+  (func (param $p ${ptrType})
+    (drop (${ptrType}.add (${ptrType}.const 1) (memory.size)))
+    (drop (${ptrType}.add (${ptrType}.const 1) (memory.grow (${ptrType}.const 1))))
+    (memory.copy (local.get $p) (${ptrType}.const 0) (${ptrType}.const 628))
+    (memory.fill (local.get $p) (i32.const 37) (${ptrType}.const 1024))
+    (memory.init $seg (local.get $p) (i32.const 3) (i32.const 5))
+))`)), memType == ptrType);
+}
+
+// SIMD
+if (wasmSimdEnabled()) {
+    for (let [memType, ptrType] of memTypes ) {
+        for (let offs of validOffsets[memType]) {
+            assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory ${memType} 1)
+  (func (param $p ${ptrType}) (param $v v128) (param $w v128)
+    (drop (i8x16.add (local.get $w) (v128.load ${offs} (local.get $p))))
+    (v128.store ${offs} (local.get $p) (local.get $v))
+    (drop (i8x16.add (local.get $w) (v128.load8_splat ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load16_splat ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load32_splat ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load64_splat ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load32_zero ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load64_zero ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load8_lane ${offs} 1 (local.get $p) (local.get $v))))
+    (drop (i8x16.add (local.get $w) (v128.load16_lane ${offs} 1 (local.get $p) (local.get $v))))
+    (drop (i8x16.add (local.get $w) (v128.load32_lane ${offs} 1 (local.get $p) (local.get $v))))
+    (drop (i8x16.add (local.get $w) (v128.load64_lane ${offs} 1 (local.get $p) (local.get $v))))
+    (v128.store8_lane ${offs} 1 (local.get $p) (local.get $v))
+    (v128.store16_lane ${offs} 1 (local.get $p) (local.get $v))
+    (v128.store32_lane ${offs} 1 (local.get $p) (local.get $v))
+    (v128.store64_lane ${offs} 1 (local.get $p) (local.get $v))
+    (drop (i8x16.add (local.get $w) (v128.load8x8_s ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load8x8_u ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load16x4_s ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load16x4_u ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load32x2_s ${offs} (local.get $p))))
+    (drop (i8x16.add (local.get $w) (v128.load32x2_u ${offs} (local.get $p))))
+))`)), memType == ptrType);
+        }
+    }
+}
+
+// Threads
+if (wasmThreadsEnabled()) {
+    for (let [memType, ptrType] of memTypes ) {
+        for (let offs of validOffsets[memType]) {
+            assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory ${memType} 1 100 shared)
+  (func (param $p ${ptrType}) (param $i i32) (param $l i64)
+    (drop (i32.add (i32.const 1) (memory.atomic.wait32 ${offs} (local.get $p) (i32.const 0) (i64.const 37))))
+    (drop (i32.add (i32.const 1) (memory.atomic.wait64 ${offs} (local.get $p) (i64.const 0) (i64.const 37))))
+    (drop (i32.add (i32.const 1) (memory.atomic.notify ${offs} (local.get $p) (i32.const 1))))
+))`)), memType == ptrType);
+
+            for (let [ty,size,sx] of
+                 [['i32','','','',],['i32','8','_u'],['i32','16','_u'],
+                  ['i64','',''],['i64','8','_u'],['i64','16','_u'],['i64','32','_u']]) {
+                assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory ${memType} 1 100 shared)
+  (func (param $p ${ptrType}) (param $vi32 i32) (param $vi64 i64)
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.load${size}${sx} ${offs} (local.get $p))))
+    (${ty}.atomic.store${size} ${offs} (local.get $p) (local.get $v${ty}))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.add${sx} ${offs} (local.get $p) (local.get $v${ty}))))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.sub${sx} ${offs} (local.get $p) (local.get $v${ty}))))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.and${sx} ${offs} (local.get $p) (local.get $v${ty}))))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.or${sx} ${offs} (local.get $p) (local.get $v${ty}))))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.xor${sx} ${offs} (local.get $p) (local.get $v${ty}))))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.xchg${sx} ${offs} (local.get $p) (local.get $v${ty}))))
+    (drop (${ty}.add (${ty}.const 1) (${ty}.atomic.rmw${size}.cmpxchg${sx} ${offs} (local.get $p) (local.get $v${ty}) (${ty}.const 37))))
+))`)), memType == ptrType);
+            }
+
+        }
+    }
+}
+
+// Cursorily check that invalid offsets are rejected.
+
+assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory i32 1)
+  (func (param $p i32)
+    (drop (i32.load offset=0x100000000 (local.get $p)))))`)), false);
+
+
+// For Memory64, any valid wat-syntaxed offset is valid.
+
+assertEq(WebAssembly.validate(wasmTextToBinary(`
+(module
+  (memory i64 1)
+  (func (param $p i64)
+    (drop (i32.load offset=0x1000000000000 (local.get $p)))))`)), true);
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// EXECUTION
+
+// Smoketest: Can we actually allocate a memory larger than 4GB?
+
+if (getBuildConfiguration()["pointer-byte-size"] == 8) {
+    // TODO: "index" is not yet part of the spec
+    // https://github.com/WebAssembly/memory64/issues/24
+
+    try {
+        new WebAssembly.Memory({index:"i64", initial:65536 * 1.5, maximum:65536 * 2});
+    } catch (e) {
+        // OOM is OK.
+        if (!(e instanceof WebAssembly.RuntimeError) || !String(e).match(/too many memory pages/)) {
+            throw e;
+        }
+    }
+}
+
+// JS-API
+
+if (WebAssembly.Function) {
+    // TODO: "index" is not yet part of the spec
+    // TODO: values outside the u32 range are not yet part of the spec
+    // https://github.com/WebAssembly/memory64/issues/24
+
+    let m64 = new WebAssembly.Memory({index:"i64", initial:1});
+    assertEq(m64.type().index, "i64");
+
+    let m32 = new WebAssembly.Memory({initial:1});
+    assertEq(m32.type().index, "i32");
+
+    let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 1 0x100000000))`)));
+    assertEq(ins.exports.mem.type().minimum, 1);
+    assertEq(ins.exports.mem.type().maximum, 0x100000000);
+}
+
+// Instructions
+
+const SMALL = 64;  // < offsetguard everywhere
+const BIG = 131072;  // > offsetguard on 32-bit
+const HUGE = 2147483656; // > offsetguard on 64-bit
+const VAST = 0x112001300;   // > 4GB
+
+function makeTest(LOC, INITIAL, MAXIMUM, SHARED) {
+    const v128Prefix =
+` (func $stash (param v128)
+    (v128.store (i64.const 0) (local.get 0)))
+
+  (func $unstash (result v128)
+    (v128.load (i64.const 0)))
+`;
+
+    const readV128Code =
+` (func (export "readv128@0") (param $p i64)
+    (call $stash (v128.load (local.get $p))))
+
+  (func (export "readv128@small") (param $p i64)
+    (call $stash (v128.load offset=${SMALL} (local.get $p))))
+
+  (func (export "readv128@big") (param $p i64)
+    (call $stash (v128.load offset=${BIG} (local.get $p))))
+
+  (func (export "readv128@huge") (param $p i64)
+    (call $stash (v128.load offset=${HUGE} (local.get $p))))
+
+  (func (export "readv128/const@0")
+    (call $stash (v128.load (i64.const ${LOC}))))
+
+  (func (export "readv128/const@small")
+    (call $stash (v128.load offset=${SMALL} (i64.const ${LOC}))))
+
+  (func (export "readv128/const@big")
+    (call $stash (v128.load offset=${BIG} (i64.const ${LOC}))))
+
+  (func (export "v128.load_splat@small") (param $p i64)
+    (call $stash (v128.load32_splat offset=${SMALL} (local.get $p))))
+
+  (func (export "v128.load_zero@small") (param $p i64)
+    (call $stash (v128.load32_zero offset=${SMALL} (local.get $p))))
+
+  (func (export "v128.load_extend@small") (param $p i64)
+    (call $stash (v128.load32x2_u offset=${SMALL} (local.get $p))))
+
+  (func (export "v128.load_lane@small") (param $p i64)
+    (call $stash (v128.load32_lane offset=${SMALL} 2 (local.get $p) (call $unstash))))
+`;
+
+    const writeV128Code =
+` (func (export "writev128@0") (param $p i64)
+    (v128.store (local.get $p) (call $unstash)))
+
+  (func (export "writev128@small") (param $p i64)
+    (v128.store offset=${SMALL} (local.get $p) (call $unstash)))
+
+  (func (export "writev128@big") (param $p i64)
+    (v128.store offset=${BIG} (local.get $p) (call $unstash)))
+
+  (func (export "writev128@huge") (param $p i64)
+    (v128.store offset=${HUGE} (local.get $p) (call $unstash)))
+
+  (func (export "writev128/const@0")
+    (v128.store (i64.const ${LOC}) (call $unstash)))
+
+  (func (export "writev128/const@small")
+    (v128.store offset=${SMALL} (i64.const ${LOC}) (call $unstash)))
+
+  (func (export "writev128/const@big")
+    (v128.store offset=${BIG} (i64.const ${LOC}) (call $unstash)))
+
+  (func (export "v128.store_lane@small") (param $p i64)
+    (v128.store32_lane offset=${SMALL} 2 (local.get $p) (call $unstash)))
+`;
+
+    const ins = wasmEvalText(`
+(module
+  (memory (export "mem") i64 ${INITIAL} ${MAXIMUM} ${SHARED})
+
+  ;; About the test cases: there are various optimizations in the engine
+  ;; for different shapes of a pointer+offset.  Constant pointers are
+  ;; resolved early; large offsets are folded early using explicit code
+  ;; with an overflow check (but "large" depends on 32-bit vs 64-bit);
+  ;; wait/notify fold offsets early regardless; zero offsets lead to
+  ;; tighter code with variable pointers; and don't get me started on
+  ;; alignment checks.  These test cases are not exhaustive but aim
+  ;; to test at least some things.
+
+  ;; TODO: more sizes for all operations, though this is not critical
+  ;; TODO: sign extending loads, again not critical
+
+  ${wasmSimdEnabled() ? v128Prefix : ""}
+
+  ;; Read i32
+  (func (export "readi32@0") (param $p i64) (result i32)
+    (i32.load (local.get $p)))
+
+  (func (export "readi32@small") (param $p i64) (result i32)
+    (i32.load offset=${SMALL} (local.get $p)))
+
+  (func (export "readi32@big") (param $p i64) (result i32)
+    (i32.load offset=${BIG} (local.get $p)))
+
+  (func (export "readi32@huge") (param $p i64) (result i32)
+    (i32.load offset=${HUGE} (local.get $p)))
+
+  (func (export "readi32@vast") (param $p i64) (result i32)
+    (i32.load offset=${VAST} (local.get $p)))
+
+  (func (export "readi32/const@0") (result i32)
+    (i32.load (i64.const ${LOC})))
+
+  (func (export "readi32/const@small") (result i32)
+    (i32.load offset=${SMALL} (i64.const ${LOC})))
+
+  (func (export "readi32/const@big") (result i32)
+    (i32.load offset=${BIG} (i64.const ${LOC})))
+
+  (func (export "readi32/const@vast") (result i32)
+    (i32.load offset=${VAST} (i64.const ${LOC})))
+
+  ;; Read i64
+  (func (export "readi64@0") (param $p i64) (result i64)
+    (i64.load (local.get $p)))
+
+  (func (export "readi64@small") (param $p i64) (result i64)
+    (i64.load offset=${SMALL} (local.get $p)))
+
+  (func (export "readi64@big") (param $p i64) (result i64)
+    (i64.load offset=${BIG} (local.get $p)))
+
+  (func (export "readi64@huge") (param $p i64) (result i64)
+    (i64.load offset=${HUGE} (local.get $p)))
+
+  (func (export "readi64@vast") (param $p i64) (result i64)
+    (i64.load offset=${VAST} (local.get $p)))
+
+  (func (export "readi64/const@0") (result i64)
+    (i64.load (i64.const ${LOC})))
+
+  (func (export "readi64/const@small") (result i64)
+    (i64.load offset=${SMALL} (i64.const ${LOC})))
+
+  (func (export "readi64/const@big") (result i64)
+    (i64.load offset=${BIG} (i64.const ${LOC})))
+
+  (func (export "readi64/const@vast") (result i64)
+    (i64.load offset=${VAST} (i64.const ${LOC})))
+
+  ;; Read v128
+  ${wasmSimdEnabled() ? readV128Code : ""}
+
+  ;; write i32
+  (func (export "writei32@0") (param $p i64) (param $v i32)
+    (i32.store (local.get $p) (local.get $v)))
+
+  (func (export "writei32@small") (param $p i64) (param $v i32)
+    (i32.store offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "writei32@big") (param $p i64) (param $v i32)
+    (i32.store offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "writei32@huge") (param $p i64) (param $v i32)
+    (i32.store offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "writei32@vast") (param $p i64) (param $v i32)
+    (i32.store offset=${VAST} (local.get $p) (local.get $v)))
+
+  (func (export "writei32/const@0") (param $v i32)
+    (i32.store (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "writei32/const@small") (param $v i32)
+    (i32.store offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "writei32/const@big") (param $v i32)
+    (i32.store offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "writei32/const@vast") (param $v i32)
+    (i32.store offset=${VAST} (i64.const ${LOC}) (local.get $v)))
+
+  ;; write i64
+  (func (export "writei64@0") (param $p i64) (param $v i64)
+    (i64.store (local.get $p) (local.get $v)))
+
+  (func (export "writei64@small") (param $p i64) (param $v i64)
+    (i64.store offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "writei64@big") (param $p i64) (param $v i64)
+    (i64.store offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "writei64@huge") (param $p i64) (param $v i64)
+    (i64.store offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "writei64@vast") (param $p i64) (param $v i64)
+    (i64.store offset=${VAST} (local.get $p) (local.get $v)))
+
+  (func (export "writei64/const@0") (param $v i64)
+    (i64.store (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "writei64/const@small") (param $v i64)
+    (i64.store offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "writei64/const@big") (param $v i64)
+    (i64.store offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "writei64/const@vast") (param $v i64)
+    (i64.store offset=${VAST} (i64.const ${LOC}) (local.get $v)))
+
+  ;; Read v128
+  ${wasmSimdEnabled() ? writeV128Code : ""}
+
+  ;; Atomic read i32
+
+  (func (export "areadi32@0") (param $p i64) (result i32)
+    (i32.atomic.load (local.get $p)))
+
+  (func (export "areadi32@small") (param $p i64) (result i32)
+    (i32.atomic.load offset=${SMALL} (local.get $p)))
+
+  (func (export "areadi32@big") (param $p i64) (result i32)
+    (i32.atomic.load offset=${BIG} (local.get $p)))
+
+  (func (export "areadi32@huge") (param $p i64) (result i32)
+    (i32.atomic.load offset=${HUGE} (local.get $p)))
+
+  (func (export "areadi32@vast") (param $p i64) (result i32)
+    (i32.atomic.load offset=${VAST} (local.get $p)))
+
+  (func (export "areadi32/const@0") (result i32)
+    (i32.atomic.load (i64.const ${LOC})))
+
+  (func (export "areadi32/const@small") (result i32)
+    (i32.atomic.load offset=${SMALL} (i64.const ${LOC})))
+
+  (func (export "areadi32/const@big") (result i32)
+    (i32.atomic.load offset=${BIG} (i64.const ${LOC})))
+
+  (func (export "areadi32/const@vast") (result i32)
+    (i32.atomic.load offset=${VAST} (i64.const ${LOC})))
+
+  ;; Atomic read i64
+
+  (func (export "areadi64@0") (param $p i64) (result i64)
+    (i64.atomic.load (local.get $p)))
+
+  (func (export "areadi64@small") (param $p i64) (result i64)
+    (i64.atomic.load offset=${SMALL} (local.get $p)))
+
+  (func (export "areadi64@big") (param $p i64) (result i64)
+    (i64.atomic.load offset=${BIG} (local.get $p)))
+
+  (func (export "areadi64@huge") (param $p i64) (result i64)
+    (i64.atomic.load offset=${HUGE} (local.get $p)))
+
+  (func (export "areadi64@vast") (param $p i64) (result i64)
+    (i64.atomic.load offset=${VAST} (local.get $p)))
+
+  (func (export "areadi64/const@0") (result i64)
+    (i64.atomic.load (i64.const ${LOC})))
+
+  (func (export "areadi64/const@small") (result i64)
+    (i64.atomic.load offset=${SMALL} (i64.const ${LOC})))
+
+  (func (export "areadi64/const@big") (result i64)
+    (i64.atomic.load offset=${BIG} (i64.const ${LOC})))
+
+  (func (export "areadi64/const@vast") (result i64)
+    (i64.atomic.load offset=${VAST} (i64.const ${LOC})))
+
+  ;; Atomic write i32
+
+  (func (export "awritei32@0") (param $p i64) (param $v i32)
+    (i32.atomic.store (local.get $p) (local.get $v)))
+
+  (func (export "awritei32@small") (param $p i64) (param $v i32)
+    (i32.atomic.store offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "awritei32@big") (param $p i64) (param $v i32)
+    (i32.atomic.store offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "awritei32@huge") (param $p i64) (param $v i32)
+    (i32.atomic.store offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "awritei32@vast") (param $p i64) (param $v i32)
+    (i32.atomic.store offset=${VAST} (local.get $p) (local.get $v)))
+
+  (func (export "awritei32/const@0") (param $v i32)
+    (i32.atomic.store (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "awritei32/const@small") (param $v i32)
+    (i32.atomic.store offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "awritei32/const@big") (param $v i32)
+    (i32.atomic.store offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "awritei32/const@vast") (param $v i32)
+    (i32.atomic.store offset=${VAST} (i64.const ${LOC}) (local.get $v)))
+
+  ;; Atomic write i64
+
+  (func (export "awritei64@0") (param $p i64) (param $v i64)
+    (i64.atomic.store (local.get $p) (local.get $v)))
+
+  (func (export "awritei64@small") (param $p i64) (param $v i64)
+    (i64.atomic.store offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "awritei64@big") (param $p i64) (param $v i64)
+    (i64.atomic.store offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "awritei64@huge") (param $p i64) (param $v i64)
+    (i64.atomic.store offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "awritei64@vast") (param $p i64) (param $v i64)
+    (i64.atomic.store offset=${VAST} (local.get $p) (local.get $v)))
+
+  (func (export "awritei64/const@0") (param $v i64)
+    (i64.atomic.store (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "awritei64/const@small") (param $v i64)
+    (i64.atomic.store offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "awritei64/const@big") (param $v i64)
+    (i64.atomic.store offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "awritei64/const@vast") (param $v i64)
+    (i64.atomic.store offset=${VAST} (i64.const ${LOC}) (local.get $v)))
+
+  ;; xchg i32
+
+  (func (export "xchgi32@0") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg (local.get $p) (local.get $v)))
+
+  (func (export "xchgi32@small") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "xchgi32@big") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "xchgi32@huge") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "xchgi32/const@0") (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xchgi32/const@small") (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xchgi32/const@big") (param $v i32) (result i32)
+    (i32.atomic.rmw.xchg offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; xchg i64
+
+  (func (export "xchgi64@0") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg (local.get $p) (local.get $v)))
+
+  (func (export "xchgi64@small") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "xchgi64@big") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "xchgi64@huge") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "xchgi64/const@0") (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xchgi64/const@small") (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xchgi64/const@big") (param $v i64) (result i64)
+    (i64.atomic.rmw.xchg offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; add i32
+
+  (func (export "addi32@0") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.add (local.get $p) (local.get $v)))
+
+  (func (export "addi32@small") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.add offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "addi32@big") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.add offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "addi32@huge") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.add offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "addi32/const@0") (param $v i32) (result i32)
+    (i32.atomic.rmw.add (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "addi32/const@small") (param $v i32) (result i32)
+    (i32.atomic.rmw.add offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "addi32/const@big") (param $v i32) (result i32)
+    (i32.atomic.rmw.add offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; add i64
+
+  (func (export "addi64@0") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.add (local.get $p) (local.get $v)))
+
+  (func (export "addi64@small") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.add offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "addi64@big") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.add offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "addi64@huge") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.add offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "addi64/const@0") (param $v i64) (result i64)
+    (i64.atomic.rmw.add (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "addi64/const@small") (param $v i64) (result i64)
+    (i64.atomic.rmw.add offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "addi64/const@big") (param $v i64) (result i64)
+    (i64.atomic.rmw.add offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; sub i32
+
+  (func (export "subi32@0") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.sub (local.get $p) (local.get $v)))
+
+  (func (export "subi32@small") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.sub offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "subi32@big") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.sub offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "subi32@huge") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.sub offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "subi32/const@0") (param $v i32) (result i32)
+    (i32.atomic.rmw.sub (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "subi32/const@small") (param $v i32) (result i32)
+    (i32.atomic.rmw.sub offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "subi32/const@big") (param $v i32) (result i32)
+    (i32.atomic.rmw.sub offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; sub i64
+
+  (func (export "subi64@0") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.sub (local.get $p) (local.get $v)))
+
+  (func (export "subi64@small") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.sub offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "subi64@big") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.sub offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "subi64@huge") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.sub offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "subi64/const@0") (param $v i64) (result i64)
+    (i64.atomic.rmw.sub (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "subi64/const@small") (param $v i64) (result i64)
+    (i64.atomic.rmw.sub offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "subi64/const@big") (param $v i64) (result i64)
+    (i64.atomic.rmw.sub offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; and i32
+
+  (func (export "andi32@0") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.and (local.get $p) (local.get $v)))
+
+  (func (export "andi32@small") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.and offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "andi32@big") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.and offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "andi32@huge") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.and offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "andi32/const@0") (param $v i32) (result i32)
+    (i32.atomic.rmw.and (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "andi32/const@small") (param $v i32) (result i32)
+    (i32.atomic.rmw.and offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "andi32/const@big") (param $v i32) (result i32)
+    (i32.atomic.rmw.and offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; and i64
+
+  (func (export "andi64@0") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.and (local.get $p) (local.get $v)))
+
+  (func (export "andi64@small") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.and offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "andi64@big") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.and offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "andi64@huge") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.and offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "andi64/const@0") (param $v i64) (result i64)
+    (i64.atomic.rmw.and (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "andi64/const@small") (param $v i64) (result i64)
+    (i64.atomic.rmw.and offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "andi64/const@big") (param $v i64) (result i64)
+    (i64.atomic.rmw.and offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; or i32
+
+  (func (export "ori32@0") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.or (local.get $p) (local.get $v)))
+
+  (func (export "ori32@small") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.or offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "ori32@big") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.or offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "ori32@huge") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.or offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "ori32/const@0") (param $v i32) (result i32)
+    (i32.atomic.rmw.or (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "ori32/const@small") (param $v i32) (result i32)
+    (i32.atomic.rmw.or offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "ori32/const@big") (param $v i32) (result i32)
+    (i32.atomic.rmw.or offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; or i64
+
+  (func (export "ori64@0") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.or (local.get $p) (local.get $v)))
+
+  (func (export "ori64@small") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.or offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "ori64@big") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.or offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "ori64@huge") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.or offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "ori64/const@0") (param $v i64) (result i64)
+    (i64.atomic.rmw.or (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "ori64/const@small") (param $v i64) (result i64)
+    (i64.atomic.rmw.or offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "ori64/const@big") (param $v i64) (result i64)
+    (i64.atomic.rmw.or offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; xor i32
+
+  (func (export "xori32@0") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xor (local.get $p) (local.get $v)))
+
+  (func (export "xori32@small") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xor offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "xori32@big") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xor offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "xori32@huge") (param $p i64) (param $v i32) (result i32)
+    (i32.atomic.rmw.xor offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "xori32/const@0") (param $v i32) (result i32)
+    (i32.atomic.rmw.xor (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xori32/const@small") (param $v i32) (result i32)
+    (i32.atomic.rmw.xor offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xori32/const@big") (param $v i32) (result i32)
+    (i32.atomic.rmw.xor offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; xor i64
+
+  (func (export "xori64@0") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xor (local.get $p) (local.get $v)))
+
+  (func (export "xori64@small") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xor offset=${SMALL} (local.get $p) (local.get $v)))
+
+  (func (export "xori64@big") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xor offset=${BIG} (local.get $p) (local.get $v)))
+
+  (func (export "xori64@huge") (param $p i64) (param $v i64) (result i64)
+    (i64.atomic.rmw.xor offset=${HUGE} (local.get $p) (local.get $v)))
+
+  (func (export "xori64/const@0") (param $v i64) (result i64)
+    (i64.atomic.rmw.xor (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xori64/const@small") (param $v i64) (result i64)
+    (i64.atomic.rmw.xor offset=${SMALL} (i64.const ${LOC}) (local.get $v)))
+
+  (func (export "xori64/const@big") (param $v i64) (result i64)
+    (i64.atomic.rmw.xor offset=${BIG} (i64.const ${LOC}) (local.get $v)))
+
+  ;; cmpxchg i32
+
+  (func (export "cmpxchgi32@0") (param $p i64) (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi32@small") (param $p i64) (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg offset=${SMALL} (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi32@big") (param $p i64) (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg offset=${BIG} (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi32@huge") (param $p i64) (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg offset=${HUGE} (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi32/const@0") (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg (i64.const ${LOC}) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi32/const@small") (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg offset=${SMALL} (i64.const ${LOC}) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi32/const@big") (param $expect i32) (param $new i32) (result i32)
+    (i32.atomic.rmw.cmpxchg offset=${BIG} (i64.const ${LOC}) (local.get $expect) (local.get $new)))
+
+  ;; cmpxchg i64
+
+  (func (export "cmpxchgi64@0") (param $p i64) (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi64@small") (param $p i64) (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg offset=${SMALL} (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi64@big") (param $p i64) (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg offset=${BIG} (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi64@huge") (param $p i64) (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg offset=${HUGE} (local.get $p) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi64/const@0") (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg (i64.const ${LOC}) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi64/const@small") (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg offset=${SMALL} (i64.const ${LOC}) (local.get $expect) (local.get $new)))
+
+  (func (export "cmpxchgi64/const@big") (param $expect i64) (param $new i64) (result i64)
+    (i64.atomic.rmw.cmpxchg offset=${BIG} (i64.const ${LOC}) (local.get $expect) (local.get $new)))
+
+  ;; wait
+
+  (func (export "waiti32@small") (param $p i64) (result i32)
+    (memory.atomic.wait32 offset=${SMALL} (local.get $p) (i32.const 1) (i64.const 0)))
+
+  (func (export "waiti32@huge") (param $p i64) (result i32)
+    (memory.atomic.wait32 offset=${HUGE} (local.get $p) (i32.const 1) (i64.const 0)))
+
+  (func (export "waiti64@small") (param $p i64) (result i32)
+    (memory.atomic.wait64 offset=${SMALL} (local.get $p) (i64.const 1) (i64.const 0)))
+
+  (func (export "waiti64@huge") (param $p i64) (result i32)
+    (memory.atomic.wait64 offset=${HUGE} (local.get $p) (i64.const 1) (i64.const 0)))
+
+  ;; wake
+
+  (func (export "wake@0") (param $p i64) (result i32)
+    (memory.atomic.notify (local.get $p) (i32.const 1)))
+
+  (func (export "wake@small") (param $p i64) (result i32)
+    (memory.atomic.notify offset=${SMALL} (local.get $p) (i32.const 1)))
+
+  (func (export "wake@big") (param $p i64) (result i32)
+    (memory.atomic.notify offset=${BIG} (local.get $p) (i32.const 1)))
+
+  (func (export "wake@huge") (param $p i64) (result i32)
+    (memory.atomic.notify offset=${HUGE} (local.get $p) (i32.const 1)))
+)
+`);
+    return ins;
+}
+
+function i32Random() {
+    // Limit this to small positive numbers to keep life simple.
+    for (;;) {
+        let r = (Math.random() * 0x3FFF_FFFF) | 0;
+        if (r != 0)
+            return r;
+    }
+}
+
+function i64Random() {
+    return (BigInt(i32Random()) << 32n) | BigInt(i32Random());
+}
+
+function Random(sz) {
+    if (sz == 4)
+        return i32Random();
+    return i64Random();
+}
+
+function Random2(sz) {
+    return [Random(sz), Random(sz)];
+}
+
+function Random4(sz) {
+    return [Random(sz), Random(sz), Random(sz), Random(sz)];
+}
+
+function Zero(sz) {
+    if (sz == 4)
+        return 0;
+    return 0n;
+}
+
+function testRead(ins, mem, LOC, prefix) {
+    let r = 0;
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+    let NM = prefix + "readi" + (SZ * 8);
+
+    // Read in-bounds
+
+    r = Random(SZ);
+    mem[LOC / SZ] = r;
+    assertEq(ins.exports[NM + "@0"](BigInt(LOC)), r);
+    assertEq(ins.exports[NM + "/const@0"](), r);
+
+    mem[(len / SZ) - 1] = Zero(SZ);
+    assertEq(ins.exports[NM + "@0"](BigInt(len - SZ)), Zero(SZ)); // Just barely in-bounds
+
+    r = Random(SZ);
+    mem[(LOC + SMALL) / SZ] = r;
+    assertEq(ins.exports[NM + "@small"](BigInt(LOC)), r);
+    assertEq(ins.exports[NM + "/const@small"](), r);
+
+    if (len >= LOC + BIG + SZ) {
+        r = Random(SZ);
+        mem[(LOC + BIG) / SZ] = r;
+        assertEq(ins.exports[NM + "@big"](BigInt(LOC)), r);
+        assertEq(ins.exports[NM + "/const@big"](), r);
+    }
+
+    if (len >= LOC + VAST + SZ) {
+        r = Random(SZ);
+        mem[(LOC + VAST) / SZ] = r;
+        assertEq(ins.exports[NM + "@vast"](BigInt(LOC)), r);
+        assertEq(ins.exports[NM + "/const@vast"](), r);
+    }
+
+    // Read out-of-bounds
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len-(SZ-1))),
+                       WebAssembly.RuntimeError,
+                       prefix == "" ? /out of bounds/ : /unaligned memory access/);
+
+    // This is OOB if we consider the whole pointer as we must, but if we
+    // mistakenly only look at the low bits then it's in-bounds.
+    if (len < 0x1_0000_0000) {
+        assertErrorMessage(() => ins.exports[NM + "@0"](0x1_0000_0000n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports[NM + "@huge"](0n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+
+    if (len < VAST) {
+        assertErrorMessage(() => ins.exports[NM + "@vast"](0n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+}
+
+function testReadV128(ins, mem, LOC) {
+    let r = 0;
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+    let NM = "readv128";
+
+    assertEq(SZ, 4);
+
+    // Read in-bounds
+
+    r = Random4(4);
+    mem.set(r, LOC / SZ);
+    ins.exports[NM + "@0"](BigInt(LOC))
+    assertSame(mem.slice(0, 4), r);
+    ins.exports[NM + "/const@0"]();
+    assertSame(mem.slice(0, 4), r);
+
+    r = new Int32Array([0,0,0,0]);
+    mem.set(r, (len / SZ) - 4);
+    ins.exports[NM + "@0"](BigInt(len - (SZ * 4)));  // Just barely in-bounds
+    assertSame(mem.slice(0, 4), r);
+
+    r = Random4(SZ);
+    mem.set(r, (LOC + SMALL) / SZ);
+    ins.exports[NM + "@small"](BigInt(LOC))
+    assertSame(mem.slice(0, 4), r);
+    ins.exports[NM + "/const@small"]();
+    assertSame(mem.slice(0, 4), r);
+
+    if (len >= LOC + BIG + SZ * 4) {
+        r = Random4(SZ);
+        mem.set(r, (LOC + BIG) / SZ);
+        ins.exports[NM + "@big"](BigInt(LOC));
+        assertSame(mem.slice(0, 4), r);
+        ins.exports[NM + "/const@big"]();
+        assertSame(mem.slice(0, 4), r);
+    }
+
+    // Read out-of-bounds
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len-((SZ*4)-1))),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    // This is OOB if we consider the whole pointer as we must, but if we
+    // mistakenly only look at the low bits then it's in-bounds.
+    if (len < 0x1_0000_0000) {
+        assertErrorMessage(() => ins.exports[NM + "@0"](0x1_0000_0000n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports[NM + "@huge"](0n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+
+    // Superficial testing of other load operations
+
+    r = i32Random()
+    mem[(LOC + SMALL) / SZ] = r;
+    ins.exports["v128.load_splat@small"](BigInt(LOC));
+    assertSame(mem.slice(0, 4), [r, r, r, r]);
+
+    r = i32Random()
+    mem[(LOC + SMALL) / SZ] = r;
+    ins.exports["v128.load_zero@small"](BigInt(LOC));
+    assertSame(mem.slice(0, 4), [r, 0, 0, 0]);
+
+    r = Random2(SZ)
+    mem.set(r, (LOC + SMALL) / SZ);
+    ins.exports["v128.load_extend@small"](BigInt(LOC));
+    assertSame(mem.slice(0, 4), [r[0], 0, r[1], 0]);
+
+    r = Random4(SZ)
+    mem.set(r, 0);
+    let s = i32Random()
+    mem[(LOC + SMALL) / SZ] = s;
+    ins.exports["v128.load_lane@small"](BigInt(LOC));
+    assertSame(mem.slice(0, 4), [r[0], r[1], s, r[3]]);
+}
+
+function testWrite(ins, mem, LOC, prefix) {
+    let r = 0;
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+    let WNM = prefix + "writei" + (SZ * 8);
+    let RNM = prefix + "readi" + (SZ * 8);
+
+    // Write in-bounds
+
+    r = Random(SZ);
+    ins.exports[WNM + "@0"](BigInt(LOC), r);
+    assertEq(ins.exports[RNM + "@0"](BigInt(LOC)), r);
+
+    r = Random(SZ);
+    ins.exports[WNM + "@small"](BigInt(LOC), r);
+    assertEq(ins.exports[RNM + "@small"](BigInt(LOC)), r);
+
+    if (len >= LOC + BIG + SZ) {
+        r = Random(SZ);
+        ins.exports[WNM + "@big"](BigInt(LOC), r);
+        assertEq(ins.exports[RNM + "@big"](BigInt(LOC)), r);
+    }
+
+    if (len >= LOC + VAST + SZ) {
+        r = Random(SZ);
+        ins.exports[WNM + "@vast"](BigInt(LOC), r);
+        assertEq(ins.exports[RNM + "@vast"](BigInt(LOC)), r);
+    }
+
+    r = Random(SZ);
+    ins.exports[WNM + "@0"](BigInt(len - SZ), r); // Just barely in-bounds
+    assertEq(ins.exports[RNM + "@0"](BigInt(len - SZ)), r);
+
+    // Write out-of-bounds
+
+    assertErrorMessage(() => ins.exports[WNM + "@0"](BigInt(len), Random(SZ)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports[WNM + "@0"](BigInt(len - (SZ - 1)), Random(SZ)),
+                       WebAssembly.RuntimeError,
+                       prefix == "" ? /out of bounds/ : /unaligned memory access/);
+
+    if (len < 0x1_0000_0000) {
+        let xs = ins.exports[RNM + "@0"](0n);
+        assertErrorMessage(() => ins.exports[WNM + "@0"](0x1_0000_0000n, Random(SZ)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+        // Check for scribbling
+        assertEq(ins.exports[RNM + "@0"](0n), xs);
+    }
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports[WNM + "@huge"](0n, Random(SZ)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+
+    if (len < VAST) {
+        assertErrorMessage(() => ins.exports[WNM + "@vast"](0n, Random(SZ)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+}
+
+function testWriteV128(ins, mem, LOC) {
+    let r = 0;
+    let p = 0;
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+    let WNM = "writev128";
+    let RNM = "readv128";
+
+    assertEq(SZ, 4);
+
+    // Write in-bounds
+
+    r = Random4(SZ);
+    mem.set(r, 0);
+    p = LOC / SZ;
+    ins.exports[WNM + "@0"](BigInt(LOC));
+    assertSame(mem.slice(p, p + 4), r);
+
+    r = Random4(SZ);
+    mem.set(r, 0);
+    p = (LOC + SMALL) / SZ;
+    ins.exports[WNM + "@small"](BigInt(LOC));
+    assertSame(mem.slice(p, p + 4), r);
+
+    if (len >= LOC + BIG + SZ) {
+        r = Random4(SZ);
+        mem.set(r, 0);
+        p = (LOC + BIG) / SZ;
+        ins.exports[WNM + "@big"](BigInt(LOC));
+        assertSame(mem.slice(p, p + 4), r);
+    }
+
+    r = Random4(SZ);
+    mem.set(r, 0);
+    p = (len - (SZ * 4)) / SZ;
+    ins.exports[WNM + "@0"](BigInt(len - (SZ * 4))); // Just barely in-bounds
+    assertSame(mem.slice(p, p + 4), r);
+
+    // Write out-of-bounds
+
+    assertErrorMessage(() => ins.exports[WNM + "@0"](BigInt(len)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports[WNM + "@0"](BigInt(len - ((SZ * 4) - 1))),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports[WNM + "@huge"](0n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+
+    // Superficial testing of other store operations
+
+    r = Random4(SZ);
+    mem.set(r, 0);
+    ins.exports["v128.store_lane@small"](BigInt(LOC));
+    assertEq(mem[(LOC + SMALL) / SZ], r[2]);
+}
+
+function testAtomicRMW(ins, mem, LOC, op, fn) {
+    let r = 0, s = 0;
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+    let NM = op + "i" + (SZ * 8);
+
+    [r,s] = Random2(SZ);
+    mem[LOC / SZ] = r;
+    assertEq(ins.exports[NM + "@0"](BigInt(LOC), s), r);
+    assertEq(mem[LOC / SZ], fn(r, s));
+
+    [r,s] = Random2(SZ);
+    mem[(LOC + SMALL) / SZ] = r;
+    assertEq(ins.exports[NM + "@small"](BigInt(LOC), s), r);
+    assertEq(mem[(LOC + SMALL) / SZ], fn(r, s));
+
+    if (len >= LOC + BIG + SZ) {
+        [r,s] = Random2(SZ);
+        mem[(LOC + BIG) / SZ] = r;
+        assertEq(ins.exports[NM + "@big"](BigInt(LOC), s), r);
+        assertEq(mem[(LOC + BIG) / SZ], fn(r, s));
+    }
+
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len), Zero(SZ)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len - (SZ - 1)), Zero(SZ)),
+                       WebAssembly.RuntimeError,
+                       /unaligned memory access/);
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports[NM + "@huge"](0n, Zero(SZ)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+}
+
+function testAtomicCmpxchg(ins, mem, LOC) {
+    let r = 0, s = 0;
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+    let NM = "cmpxchgi" + (SZ * 8);
+
+    [r,s] = Random2(SZ);
+    mem[LOC / SZ] = r;
+    assertEq(ins.exports[NM + "@0"](BigInt(LOC), Zero(SZ), s), r);
+    assertEq(ins.exports[NM + "@0"](BigInt(LOC), r, s), r);
+    assertEq(mem[LOC / SZ], s);
+
+    [r,s] = Random2(SZ);
+    mem[(LOC + SMALL) / SZ] = r;
+    assertEq(ins.exports[NM + "@0"](BigInt(LOC + SMALL), Zero(SZ), s), r);
+    assertEq(ins.exports[NM + "@0"](BigInt(LOC + SMALL), r, s), r);
+    assertEq(mem[(LOC + SMALL) / SZ], s);
+
+    if (len >= LOC + BIG + SZ) {
+        [r,s] = Random2(SZ);
+        mem[(LOC + BIG) / SZ] = r;
+        assertEq(ins.exports[NM + "@0"](BigInt(LOC + BIG), Zero(SZ), s), r);
+        assertEq(ins.exports[NM + "@0"](BigInt(LOC + BIG), r, s), r);
+        assertEq(mem[(LOC + BIG) / SZ], s);
+    }
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len), Zero(SZ), Zero(SZ)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports[NM + "@0"](BigInt(len - (SZ - 1)), Zero(SZ), Zero(SZ)),
+                       WebAssembly.RuntimeError,
+                       /unaligned memory access/);
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports[NM + "@huge"](0n, Zero(SZ), Zero(SZ)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+}
+
+function testAtomicWake(ins, mem, LOC) {
+    let SZ = mem.BYTES_PER_ELEMENT;
+    let len = mem.length * SZ;
+
+    assertEq(ins.exports["wake@0"](BigInt(LOC)), 0);
+    assertEq(ins.exports["wake@small"](BigInt(LOC)), 0);
+    if (len >= LOC + BIG + SZ) {
+        assertEq(ins.exports["wake@big"](BigInt(LOC)), 0);
+    }
+
+    assertErrorMessage(() => ins.exports["wake@0"](BigInt(len)),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    assertErrorMessage(() => ins.exports["wake@0"](BigInt(len - (SZ - 1))),
+                       WebAssembly.RuntimeError,
+                       /unaligned memory access/);
+
+    if (len < HUGE) {
+        assertErrorMessage(() => ins.exports["wake@huge"](BigInt(LOC)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+    }
+}
+
+// Sometimes we start memory at zero to disable certain bounds checking
+// optimizations.  Other times we start memory at something beyond most of
+// our references to enable those optimizations.
+let configs = [[40, 0, 3], [40, 3, '']];
+
+// On 64-bit systems, test beyond 2GB and also beyond 4GB
+if (getBuildConfiguration()["pointer-byte-size"] == 8) {
+    configs.push([Math.pow(2, 31) + 40, 32771, '']);
+    configs.push([Math.pow(2, 32) + 40, 65539, '']);
+    configs.push([Math.pow(2, 31) + 40, 32771, 32773]);
+    configs.push([Math.pow(2, 32) + 40, 65539, 65541]);
+}
+
+for ( let shared of ['','shared'] ) {
+    for (let [LOC, start, max] of configs) {
+        if (shared != '' && max == '') {
+            continue;
+        }
+        const ins = makeTest(LOC, start, max, shared);
+        if (max != '') {
+            // This can OOM legitimately; let it.
+            let res = ins.exports.mem.grow(max - start);
+            if (res == -1) {
+                print("SPURIOUS OOM");
+                continue;
+            }
+            assertEq(res, start);
+        }
+
+        const mem32 = new Int32Array(ins.exports.mem.buffer);
+        const mem64 = new BigInt64Array(ins.exports.mem.buffer);
+
+        for ( let m of [mem32, mem64] ) {
+            testRead(ins, m, LOC, "");
+            testWrite(ins, m, LOC, "");
+            testRead(ins, m, LOC, "a");
+            testWrite(ins, m, LOC, "a");
+            testAtomicRMW(ins, m, LOC, "add", (r,s) => r+s);
+            testAtomicRMW(ins, m, LOC, "sub", (r,s) => r-s);
+            testAtomicRMW(ins, m, LOC, "and", (r,s) => r&s);
+            testAtomicRMW(ins, m, LOC, "or", (r,s) => r|s);
+            testAtomicRMW(ins, m, LOC, "xor", (r,s) => r^s);
+            testAtomicRMW(ins, m, LOC, "xchg", (r,s) => s);
+            testAtomicCmpxchg(ins, m, LOC);
+            testAtomicWake(ins, m, LOC);
+        }
+
+        if (wasmSimdEnabled()) {
+            testReadV128(ins, mem32, LOC);
+            testWriteV128(ins, mem32, LOC);
+        }
+    }
+}
+
+// Bulk memory operations
+
+function makeModule(initial, maximum, shared) {
+    return `
+(module
+  (memory (export "mem") i64 ${initial} ${maximum} ${shared})
+
+  (data $seg "0123456789")
+
+  (func (export "size") (result i64)
+    memory.size)
+
+  (func (export "grow") (param $delta i64) (result i64)
+    (memory.grow (local.get $delta)))
+
+  (func (export "copy") (param $to i64) (param $from i64) (param $len i64)
+    (memory.copy (local.get $to) (local.get $from) (local.get $len)))
+
+  (func (export "fill") (param $to i64) (param $val i32) (param $len i64)
+    (memory.fill (local.get $to) (local.get $val) (local.get $len)))
+
+  (func (export "init") (param $to i64) (param $src i32) (param $count i32)
+    (memory.init $seg (local.get $to) (local.get $src) (local.get $count)))
+)`;
+}
+
+for ( let shared of ['','shared'] ) {
+    let ins = wasmEvalText(makeModule(1, 3, shared));
+
+    assertEq(ins.exports.size(), 1n);
+
+    // OOM with very low probability will result in test failure
+    assertEq(ins.exports.grow(2n), 1n);
+    assertEq(ins.exports.size(), 3n);
+
+    // OOM with very low probability will result in test failure
+    assertEq(ins.exports.grow(1n), -1n);
+    assertEq(ins.exports.size(), 3n);
+
+    // More than max pages
+    assertEq(ins.exports.grow(100000n), -1n);
+    assertEq(ins.exports.size(), 3n);
+
+    // More than 2^48 pages
+    assertEq(ins.exports.grow(0x1_0000_0000_0000n), -1n);
+    assertEq(ins.exports.size(), 3n);
+
+    // More than 2^48 pages - interpreted as unsigned
+    assertEq(ins.exports.grow(-1n), -1n);
+    assertEq(ins.exports.size(), 3n);
+
+    var mem = new Uint8Array(ins.exports.mem.buffer);
+    var val = [1,2,3,4,5];
+    mem.set(val, 20);
+    ins.exports.copy(40n, 20n, 5n);
+    assertSame(val, mem.slice(40, 45));
+
+    ins.exports.fill(39n, 37, 8n);
+    assertSame(iota(8).map(_ => 37), mem.slice(39, 47));
+
+    ins.exports.init(128n, 1, 5);
+    assertSame(iota(5).map(x => x+49), mem.slice(128, 133));
+}
+
+if (getBuildConfiguration()["pointer-byte-size"] == 8) {
+    for ( let shared of ['','shared'] ) {
+        let limit = wasmMaxMemoryPages('i64');
+        let initial = 65537;
+        let maximum = limit + 1;
+        let pagesize = 65536n;
+
+        let ins = wasmEvalText(makeModule(initial, maximum, shared));
+
+        assertEq(ins.exports.size(), BigInt(initial));
+
+        // This can OOM legitimately; let it.
+        {
+            let res = ins.exports.grow(2n);
+            if (res == -1) {
+                print("SPURIOUS OOM");
+                continue;
+            }
+            assertEq(res, BigInt(initial));
+        }
+        assertEq(ins.exports.size(), BigInt(initial + 2));
+
+        // This must fail
+        assertEq(ins.exports.grow(BigInt(limit - (initial + 2) + 1)), -1n);
+        assertEq(ins.exports.size(), BigInt(initial + 2));
+
+        // This can OOM legitimately; let it.
+        {
+            let res = ins.exports.grow(BigInt(limit - (initial + 2)));
+            if (res == -1) {
+                print("SPURIOUS OOM");
+                continue;
+            }
+            assertEq(res, BigInt(initial + 2));
+        }
+        assertEq(ins.exports.size(), BigInt(limit));
+
+        let mem = new Uint8Array(ins.exports.mem.buffer);
+
+        let copyval = [1,2,3,4,5];
+        let source = 20n;
+        let target = BigInt(initial) * pagesize + 40n;
+        let oobTarget = BigInt(limit) * pagesize - 1n;
+
+        // Copy from memory below 4GB to memory beyond 4GB
+        mem.set(copyval, Number(source));
+        ins.exports.copy(target, source, BigInt(copyval.length));
+        assertSame(copyval, mem.slice(Number(target), Number(target) + copyval.length))
+
+        // Try to copy out of bounds
+        // src and target are both in bounds but len brings it oob
+        assertErrorMessage(() => ins.exports.copy(oobTarget, source, BigInt(copyval.length)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+        assertEq(mem[Number(oobTarget-1n)], 0);
+        assertErrorMessage(() => ins.exports.copy(-1n, source, BigInt(copyval.length)),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+        assertEq(mem[Number(oobTarget-1n)], 0);
+
+        // Fill above 4GB
+        ins.exports.fill(target, 37, 30n);
+        assertSame(iota(30).map(_ => 37), mem.slice(Number(target), Number(target) + 30));
+
+        // Try to fill out of bounds
+        assertErrorMessage(() => ins.exports.fill(oobTarget, 37, 2n),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+        assertEq(mem[Number(oobTarget-1n)], 0);
+
+        // Init above 4GB
+        ins.exports.init(target, 1, 5);
+        assertSame(iota(5).map(x => x+49), mem.slice(Number(target), Number(target)+5));
+
+        // Try to init out of bounds
+        assertErrorMessage(() => ins.exports.init(oobTarget, 1, 5),
+                           WebAssembly.RuntimeError,
+                           /out of bounds/);
+        assertEq(mem[Number(oobTarget-1n)], 0);
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/memory64/data-active.js b/js/src/jit-test/tests/wasm/memory64/data-active.js
new file mode 100644
index 0000000000..7f40861aba
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/data-active.js
@@ -0,0 +1,34 @@
+// |jit-test| allow-oom; skip-if: !canRunHugeMemoryTests()
+
+function testIt(s, addr) {
+    try {
+        var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 65537)
+  (data (i64.const ${addr}) "${s}"))`)));
+    } catch (e) {
+        if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+            return;
+        }
+        throw e;
+    }
+    var mem = new Uint8Array(ins.exports.mem.buffer);
+    assertEq(String.fromCodePoint(...mem.slice(addr, addr + s.length)), s)
+}
+
+// Test that an active data segment targeting the area above 4GB works as expected
+testIt("hello, world!", 0x100000020);
+
+// Ditto, but crosses the 4GB boundary
+var s = "supercalifragilisticexpialidocious";
+testIt(s, 0x100000000 - Math.floor(s.length / 2));
+
+// This is OOB above the 4GB boundary - throws OOB during instantiation.
+// But can also throw for OOM when trying to create the memory.
+assertErrorMessage(() => new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 65537)
+  (data (i64.const ${65536*65537-10}) "supercalifragilisticexpialidocious"))`))),
+                   WebAssembly.RuntimeError,
+                   /(out of bounds)|(too many memory pages)/);
+
diff --git a/js/src/jit-test/tests/wasm/memory64/directives.txt b/js/src/jit-test/tests/wasm/memory64/directives.txt
new file mode 100644
index 0000000000..98d92a7afc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; include:wasm.js; skip-if: !wasmMemory64Enabled()
diff --git a/js/src/jit-test/tests/wasm/memory64/memory-copy-shared.js b/js/src/jit-test/tests/wasm/memory64/memory-copy-shared.js
new file mode 100644
index 0000000000..cffa6cb352
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/memory-copy-shared.js
@@ -0,0 +1,60 @@
+// |jit-test| allow-oom; slow; skip-if: !canRunHugeMemoryTests()
+
+// This is just like memory-copy.js, but it is marked slow because the
+// C++-UB-safe operations we use for out-of-line copies on shared memory are slow
+// and the >4GB copy takes a long time.
+
+var HEAPMIN=65538;
+var HEAPMAX=65540;
+var PAGESIZE=65536;
+
+try {
+    var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 ${HEAPMIN} ${HEAPMAX} shared)
+  (func (export "f") (param $dst i64) (param $src i64) (param $n i64)
+    (memory.copy (local.get $dst) (local.get $src) (local.get $n))))`)));
+} catch (e) {
+    if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+        quit(0);
+    }
+    throw e;
+}
+
+var mem = new Uint8Array(ins.exports.mem.buffer);
+var lowbase = 0xffff_1000;
+var highbase = 0x1_0000_8000;
+for ( let n=0; n < 256; n++ ) {
+    mem[n + lowbase] = n + 1;
+    mem[n + highbase] = n + 1;
+}
+
+// Copy from above 4GB to below
+doit(0, highbase, 60);
+
+// Copy from above 4GB with OOB to below
+assertErrorMessage(() => ins.exports.f(0n, BigInt(HEAPMIN*PAGESIZE-32768), 65536n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+
+// Copy from below 4GB to above
+doit(0x1_0000_0100, lowbase, 60);
+
+// Copy from below 4GB to above with OOB
+assertErrorMessage(() => ins.exports.f(BigInt(HEAPMIN*PAGESIZE-32768), BigInt(lowbase), 65536n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+
+// Copy across the 4GB boundary
+doit(0xffff_ff80, lowbase, 256);
+
+// Copy more than 4GB.  Note overlap prevents full correctness checking.
+ins.exports.f(BigInt(PAGESIZE), 0n, BigInt(PAGESIZE*(HEAPMIN-1)));
+for ( let i=0 ; i < PAGESIZE; i++ )
+    assertEq(mem[i + PAGESIZE], mem[i]);
+
+function doit(dst, src, n) {
+    ins.exports.f(BigInt(dst), BigInt(src), BigInt(n));
+    for ( let i=0 ; i < n; i++ )
+        assertEq(mem[dst + i], mem[src + i]);
+}
diff --git a/js/src/jit-test/tests/wasm/memory64/memory-copy.js b/js/src/jit-test/tests/wasm/memory64/memory-copy.js
new file mode 100644
index 0000000000..19090a079a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/memory-copy.js
@@ -0,0 +1,58 @@
+// |jit-test| allow-oom; skip-if: !canRunHugeMemoryTests()
+
+// Also see memory-copy-shared.js
+
+var HEAPMIN=65538;
+var HEAPMAX=65540;
+var PAGESIZE=65536;
+
+try {
+    var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 ${HEAPMIN} ${HEAPMAX})
+  (func (export "f") (param $dst i64) (param $src i64) (param $n i64)
+    (memory.copy (local.get $dst) (local.get $src) (local.get $n))))`)));
+} catch (e) {
+    if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+        quit(0);
+    }
+    throw e;
+}
+
+var mem = new Uint8Array(ins.exports.mem.buffer);
+var lowbase = 0xffff_1000;
+var highbase = 0x1_0000_8000;
+for ( let n=0; n < 256; n++ ) {
+    mem[n + lowbase] = n + 1;
+    mem[n + highbase] = n + 1;
+}
+
+// Copy from above 4GB to below
+doit(0, highbase, 60);
+
+// Copy from above 4GB with OOB to below
+assertErrorMessage(() => ins.exports.f(0n, BigInt(HEAPMIN*PAGESIZE-32768), 65536n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+
+// Copy from below 4GB to above
+doit(0x1_0000_0100, lowbase, 60);
+
+// Copy from below 4GB to above with OOB
+assertErrorMessage(() => ins.exports.f(BigInt(HEAPMIN*PAGESIZE-32768), BigInt(lowbase), 65536n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+
+// Copy across the 4GB boundary
+doit(0xffff_ff80, lowbase, 256);
+
+// Copy more than 4GB.  Note overlap prevents full correctness checking.
+ins.exports.f(BigInt(PAGESIZE), 0n, BigInt(PAGESIZE*(HEAPMIN-1)));
+for ( let i=0 ; i < PAGESIZE; i++ )
+    assertEq(mem[i + PAGESIZE], mem[i]);
+
+function doit(dst, src, n) {
+    ins.exports.f(BigInt(dst), BigInt(src), BigInt(n));
+    for ( let i=0 ; i < n; i++ )
+        assertEq(mem[dst + i], mem[src + i]);
+}
diff --git a/js/src/jit-test/tests/wasm/memory64/memory-fill-shared.js b/js/src/jit-test/tests/wasm/memory64/memory-fill-shared.js
new file mode 100644
index 0000000000..cd81aeba4d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/memory-fill-shared.js
@@ -0,0 +1,58 @@
+// |jit-test| allow-oom; slow; skip-if: !canRunHugeMemoryTests()
+
+// This is just like memory-fill.js, but it is marked slow because the
+// C++-UB-safe operations we use for out-of-line fills on shared memory are slow
+// and the >4GB fill takes a long time.
+
+try {
+    var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 65537 65537 shared)
+  (func (export "f") (param $p i64) (param $c i32) (param $n i64)
+    (memory.fill (local.get $p) (local.get $c) (local.get $n))))`)));
+} catch (e) {
+    if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+        quit(0);
+    }
+    throw e;
+}
+
+var mem = new Uint8Array(ins.exports.mem.buffer);
+
+// Fill above 4GB
+doit(mem, 0x100000100, 37, 14);
+
+// Fill OOB above 4GB
+assertErrorMessage(() => ins.exports.f(0x10000FFFFn, 66, 14n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+assertEq(mem[0x10000FFFF], 0);
+assertEq(mem[mem.length-1], 0);
+
+// Fill across 4GB
+doit(mem, 0x100000000 - 16, 42, 32);
+
+// Fill more than 4GB...
+ins.exports.f(0n, 86, 65536n*65537n);
+assertEq(mem[mem.length-1], 86);
+assertEq(mem[0], 86);
+
+// Fill OOB more than 4GB
+assertErrorMessage(() => ins.exports.f(1n, 75, 65536n*65537n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+assertEq(mem[1], 86);
+assertEq(mem[mem.length-1], 86);
+
+function doit(mem, addr, c, n) {
+    assertEq(mem[addr-1], 0);
+    assertEq(mem[addr], 0);
+    assertEq(mem[addr + n - 1], 0);
+    assertEq(mem[addr + n], 0);
+    ins.exports.f(BigInt(addr), c, BigInt(n));
+    assertEq(mem[addr-1], 0);
+    assertEq(mem[addr], c);
+    assertEq(mem[addr + n - 1], c);
+    assertEq(mem[addr + n], 0);
+}
+
diff --git a/js/src/jit-test/tests/wasm/memory64/memory-fill.js b/js/src/jit-test/tests/wasm/memory64/memory-fill.js
new file mode 100644
index 0000000000..500247d13c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/memory-fill.js
@@ -0,0 +1,56 @@
+// |jit-test| allow-oom; skip-if: !canRunHugeMemoryTests()
+
+// Also see memory-fill-shared.js
+
+try {
+    var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 65537)
+  (func (export "f") (param $p i64) (param $c i32) (param $n i64)
+    (memory.fill (local.get $p) (local.get $c) (local.get $n))))`)));
+} catch (e) {
+    if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+        quit(0);
+    }
+    throw e;
+}
+
+var mem = new Uint8Array(ins.exports.mem.buffer);
+
+// Fill above 4GB
+doit(mem, 0x100000100, 37, 14);
+
+// Fill OOB above 4GB
+assertErrorMessage(() => ins.exports.f(0x10000FFFFn, 66, 14n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+assertEq(mem[0x10000FFFF], 0);
+assertEq(mem[mem.length-1], 0);
+
+// Fill across 4GB
+doit(mem, 0x100000000 - 16, 42, 32);
+
+// Fill more than 4GB...
+ins.exports.f(0n, 86, 65536n*65537n);
+assertEq(mem[mem.length-1], 86);
+assertEq(mem[0], 86);
+
+// Fill OOB more than 4GB
+assertErrorMessage(() => ins.exports.f(1n, 75, 65536n*65537n),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+assertEq(mem[1], 86);
+assertEq(mem[mem.length-1], 86);
+
+function doit(mem, addr, c, n) {
+    assertEq(mem[addr-1], 0);
+    assertEq(mem[addr], 0);
+    assertEq(mem[addr + n - 1], 0);
+    assertEq(mem[addr + n], 0);
+    ins.exports.f(BigInt(addr), c, BigInt(n));
+    assertEq(mem[addr-1], 0);
+    assertEq(mem[addr], c);
+    assertEq(mem[addr + n - 1], c);
+    assertEq(mem[addr + n], 0);
+}
+
diff --git a/js/src/jit-test/tests/wasm/memory64/memory-grow.js b/js/src/jit-test/tests/wasm/memory64/memory-grow.js
new file mode 100644
index 0000000000..0316c01b45
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/memory-grow.js
@@ -0,0 +1,31 @@
+// |jit-test| allow-oom; skip-if: !canRunHugeMemoryTests()
+
+// This tests that we can grow the heap by more than 4GB.  Other grow tests are
+// in basic.js.
+
+for (let shared of ['', 'shared']) {
+    try {
+        var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 0 65540 ${shared})
+  (func (export "f") (param $delta i64) (result i64)
+    (memory.grow (local.get $delta))))`)));
+    } catch (e) {
+        if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+            quit(0);
+        }
+        throw e;
+    }
+
+    let res = ins.exports.f(65537n);
+    if (res === -1n) {
+        quit(0);                    // OOM
+    }
+    assertEq(ins.exports.mem.buffer.byteLength, 65537*65536);
+    let mem = new Uint8Array(ins.exports.mem.buffer);
+    mem[65537*65536-1] = 37;
+    assertEq(mem[65537*65536-1], 37);
+
+    assertEq(ins.exports.f(4n), -1n);
+}
+
diff --git a/js/src/jit-test/tests/wasm/memory64/memory-init.js b/js/src/jit-test/tests/wasm/memory64/memory-init.js
new file mode 100644
index 0000000000..246fc3f2d4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/memory-init.js
@@ -0,0 +1,45 @@
+// |jit-test| allow-oom; skip-if: !canRunHugeMemoryTests()
+
+var S = (function () {
+    let s = "";
+    for ( let i=0; i < 16; i++ )
+        s += "0123456789abcdef"
+    return s;
+})();
+
+for (let shared of ['', 'shared']) {
+    try {
+        var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (memory (export "mem") i64 65537 65537 ${shared})
+  (data $d "${S}")
+  (func (export "f") (param $p i64) (param $o i32) (param $n i32)
+    (memory.init $d (local.get $p) (local.get $o) (local.get $n))))`)));
+    } catch (e) {
+        if (e instanceof WebAssembly.RuntimeError && String(e).match(/too many memory pages/)) {
+            quit(0);
+        }
+        throw e;
+    }
+
+    var mem = new Uint8Array(ins.exports.mem.buffer);
+
+    // Init above 4GB
+    doit(mem, 0x1_0000_1000, 1, S.length-1);
+
+    // Init above 4GB with OOM
+    assertErrorMessage(() => ins.exports.f(0x1_0000_ff80n, 0, 256),
+                       WebAssembly.RuntimeError,
+                       /out of bounds/);
+
+    // Init across 4GB
+    doit(mem, 0xffff_ff80, 3, 200);
+}
+
+function doit(mem, addr, offs, n) {
+    ins.exports.f(BigInt(addr), offs, n);
+    for (let i=0; i < n; i++) {
+        assertEq(mem[addr+i], S.charCodeAt(offs+i));
+    }
+}
+
diff --git a/js/src/jit-test/tests/wasm/memory64/utility.js b/js/src/jit-test/tests/wasm/memory64/utility.js
new file mode 100644
index 0000000000..5035d66170
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/memory64/utility.js
@@ -0,0 +1,18 @@
+// Assert that we get a useful amount of memory for memory64 on tier-1 64-bit
+// systems with our primary compilers.
+
+var conf = getBuildConfiguration();
+
+// Only 64-bit systems
+if (conf["pointer-byte-size"] != 8) {
+    quit(0);
+}
+
+// MIPS64 tops out below 2GB
+if (conf["mips64"]) {
+    quit(0);
+}
+
+var eightGB = 8 * 1024 * 1024 * 1024;
+var pageSize = 65536;
+assertEq(wasmMaxMemoryPages("i64") >= eightGB / pageSize, true);
diff --git a/js/src/jit-test/tests/wasm/multi-value/block-run.js b/js/src/jit-test/tests/wasm/multi-value/block-run.js
new file mode 100644
index 0000000000..3b6689d2f9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/block-run.js
@@ -0,0 +1,268 @@
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)))))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32) (i32.const 10)
+      (block (param i32 i32) (result i32 i32))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (block (param i32) (result i32 i32)
+        (i32.const 10))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.add
+        (loop (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)))))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32) (i32.const 10)
+      (loop (param i32 i32) (result i32 i32))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (loop (param i32) (result i32 i32)
+        (i32.const 10))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)
+          (br 0)))))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (block (param i32 i32) (result i32 i32)
+        (br 0))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (block (param i32) (result i32 i32)
+        (i32.const 10)
+        (br 0))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)
+          (block (param i32 i32) (result i32 i32)
+            (br 1))))))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (block (param i32 i32) (result i32 i32)
+        (block (param i32 i32) (result i32 i32)
+          (br 1)))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (block (param i32 i32) (result i32 i32)
+        (block (param i32 i32) (result i32 i32)
+          (br 0)))
+      (i32.add)))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (block (param i32) (result i32 i32)
+        (i32.const 10)
+        (block (param i32 i32) (result i32 i32)
+          (br 1)))
+      (i32.add)))`,
+            42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32)
+          (then (i32.add))
+          (else (i32.sub)))))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32 i32)
+          (then
+            (drop)
+            (drop)
+            (i32.const 10)
+            (i32.const 32)))
+      (i32.sub)))`,
+             -22);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 0)
+      (if (param i32 i32) (result i32 i32)
+          (then
+            (drop)
+            (drop)
+            (i32.const 10)
+            (i32.const 32)))
+      (i32.sub)))`,
+             22);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32 i32)
+          (then (return)))
+      (i32.sub)))`,
+             10);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 0)
+      (if (param i32 i32) (result i32 i32)
+          (then (return)))
+      (i32.sub)))`,
+             22);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32 i32)
+          (then)
+          (else (return)))
+      (i32.sub)))`,
+             22);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 0)
+      (if (param i32 i32) (result i32 i32)
+          (then)
+          (else (return)))
+      (i32.sub)))`,
+             10);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (local $i i32)
+      (i32.const 0) ;; sum
+      (i32.const 10) ;; i
+      (loop $loop (param i32 i32) (result i32)
+        (local.tee $i)
+        (i32.add) ;; sum = i + sum
+        (i32.sub (local.get $i) (i32.const 1))
+        (i32.eqz (local.tee $i))
+        (if (param i32) (result i32)
+            (then)
+            (else (local.get $i) (br $loop))))))`,
+            55);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (local i32)
+      i32.const 42
+      local.get 0
+      local.get 0
+      loop (param i32 i32 i32) (result i32)
+        drop
+        drop
+      end))`,
+             42);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (block (result i32 i32)
+        (i32.popcnt (i32.const 1))
+        (i32.popcnt (i32.const 3))
+        (block (param i32 i32)
+          (i32.const 6)
+          (i32.const 7)
+          (br 1))
+        (unreachable))
+      i32.add))`,
+             13);
+
+wasmFullPass(`
+  (module
+    (func (export "run") (result i32)
+      (block (result i32 i32)
+        (i32.popcnt (i32.const 1))
+        (i32.popcnt (i32.const 3))
+        (block) ;; sync()
+        (i32.const 6)
+        (i32.const 7)
+        (br 0))
+      i32.add))`,
+             13);
diff --git a/js/src/jit-test/tests/wasm/multi-value/block-validate.js b/js/src/jit-test/tests/wasm/multi-value/block-validate.js
new file mode 100644
index 0000000000..7845c016e3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/block-validate.js
@@ -0,0 +1,266 @@
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)))))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32) (i32.const 10)
+      (block (param i32 i32) (result i32 i32))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (block (param i32) (result i32 i32)
+        (i32.const 10))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.add
+        (loop (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)))))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32) (i32.const 10)
+      (loop (param i32 i32) (result i32 i32))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (loop (param i32) (result i32 i32)
+        (i32.const 10))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)
+          (br 0)))))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (block (param i32 i32) (result i32 i32)
+        (br 0))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (block (param i32) (result i32 i32)
+        (i32.const 10)
+        (br 0))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)
+          (block (param i32 i32) (result i32 i32)
+            (br 1))))))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (block (param i32 i32) (result i32 i32)
+        (block (param i32 i32) (result i32 i32)
+          (br 1)))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (block (param i32 i32) (result i32 i32)
+        (block (param i32 i32) (result i32 i32)
+          (br 0)))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (block (param i32) (result i32 i32)
+        (i32.const 10)
+        (block (param i32 i32) (result i32 i32)
+          (br 1)))
+      (i32.add)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32)
+          (then (i32.add))
+          (else (i32.sub)))))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32 i32)
+          (then
+            (drop)
+            (drop)
+            (i32.const 10)
+            (i32.const 32)))
+      (i32.sub)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32 i32)
+          (then (return)))
+      (i32.sub)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (i32.const 1)
+      (if (param i32 i32) (result i32 i32)
+          (then)
+          (else (return)))
+      (i32.sub)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (local $i i32)
+      (i32.const 0) ;; sum
+      (i32.const 10) ;; i
+      (loop $loop (param i32 i32) (result i32)
+        (local.tee $i)
+        (i32.add) ;; sum = i + sum
+        (i32.sub (local.get $i) (i32.const 1))
+        (local.tee $i)
+        (local.get $i)
+        (br_if $loop (i32.eqz))
+        (drop))))`);
+
+// Tests the encoding: with more than 64 function types, the block type encoded
+// as an uleb will create a confusion with the valtype; an sleb is required.
+
+wasmValidateText(`
+  (module
+    ${(function () {
+        s = "";
+        for ( let i=0; i < 64; i++ ) {
+          let t = [];
+          for ( let j=0; j < 6; j++ )
+            t.push(i & (1 << j) ? "i32" : "f32");
+          s += "(func (param " + t.join(" ") + "))\n";
+        }
+        return s;
+       })()}
+    (func (result i32)
+      (i32.add
+        (block (result i32 i32)
+          (i32.const 32)
+          (i32.const 10)))))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (block $B (result i32 i32)
+        (br $B (i32.const 1) (i32.const 2))
+        (i32.const 0x1337))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (block $B (result i32 i32)
+        (i32.const 1)
+        (br $B (i32.const 2))
+        (i32.const 0x1337))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32)
+      (block $B (result i32 i32)
+        (i32.const 1)
+        (i32.const 2)
+        (br $B)
+        (i32.const 0x1337))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (param $cond i32) (result i32)
+      (block $B (result i32 i32)
+        (br_if $B (i32.const 1) (i32.const 2) (local.get $cond)))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (param $cond i32) (result i32)
+      (block $B (result i32 i32)
+        (i32.const 1)
+        (br_if $B (i32.const 2) (local.get $cond)))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (param $cond i32) (result i32)
+      (block $B (result i32 i32)
+        (i32.const 1)
+        (i32.const 2)
+        (br_if $B (local.get $cond)))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (param $cond i32) (result i32)
+      (block $B (result i32 i32)
+        (i32.const 1)
+        (i32.const 2)
+        (local.get $cond)
+        (br_if $B))
+      (drop)))`);
+
+wasmValidateText(`
+  (module
+    (func (param $index i32) (result i32)
+      (block $OUT (result i32)
+        (block $B1 (result i32 i32)
+          (block $B2 (result i32 i32)
+            (block $B3 (result i32 i32)
+              (br_table $B1 $B2 $B3 (i32.const 1) (i32.const 2) (local.get $index)))
+            (br $OUT (i32.add)))
+          (br $OUT (i32.sub)))
+        (br $OUT (i32.mul)))))`);
diff --git a/js/src/jit-test/tests/wasm/multi-value/call-js.js b/js/src/jit-test/tests/wasm/multi-value/call-js.js
new file mode 100644
index 0000000000..7af031e5f0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/call-js.js
@@ -0,0 +1,138 @@
+
+wasmFullPass(`
+  (module
+    (import "env" "f" (func $f (result i32 i32 i32)))
+    (func (export "run") (result i32)
+      (call $f)
+      i32.sub
+      i32.sub))`,
+             42,
+             { env: { f: () => [52, 10, 0] } });
+
+wasmFullPass(`
+  (module
+    (import "env" "f" (func $f (result i64 i64 i64)))
+    (func (export "run") (result i64)
+      (call $f)
+      i64.sub
+      i64.sub))`,
+             42n,
+             { env: { f: () => [52n, 10n, 0n] } });
+
+wasmFullPass(`
+  (module
+    (import "env" "f" (func $f (result f32 f32 f32)))
+    (func (export "run") (result i32)
+      (call $f)
+      f32.sub
+      f32.sub
+      i32.trunc_f32_s))`,
+             42,
+             { env: { f: () => [52.25, 10.5, 0.25] } });
+
+wasmFullPass(`
+  (module
+    (import "env" "f" (func $f (result f64 f64 f64)))
+    (func (export "run") (result i32)
+      (call $f)
+      f64.sub
+      f64.sub
+      i32.trunc_f64_s))`,
+             42,
+             { env: { f: () => [52.25, 10.5, 0.25] } });
+
+// Multiple values are returned as an iterable; it doesn't have to be an array.
+function expectMultiValuePass(f) {
+    wasmFullPass(`
+      (module
+        (import "env" "f" (func $f (result i32 i32 i32)))
+        (func (export "run") (result i32)
+          (call $f)
+          i32.sub
+          i32.sub))`,
+                 42,
+                 { env: { f } });
+}
+function expectMultiValueError(f, type, pattern) {
+    let module = new WebAssembly.Module(wasmTextToBinary(`
+      (module
+        (import "env" "f" (func $f (result i32 i32 i32)))
+        (func (export "run") (result i32)
+          (call $f)
+          i32.sub
+          i32.sub))`));
+
+    let instance = new WebAssembly.Instance(module, { env: { f } } );
+    assertErrorMessage(() => instance.exports.run(), type, pattern);
+}
+
+expectMultiValuePass(() => [52, 10, 0]);
+expectMultiValuePass(() => [32, -10, 0]);
+expectMultiValuePass(() => [52.75, 10, 0.5]); // Values converted to i32 via ToInt32.
+expectMultiValuePass(() => [42, undefined, undefined]);
+expectMultiValuePass(() => (function*() { yield 52; yield 10; yield 0; })());
+expectMultiValuePass(() => (function*() { yield '52'; yield '10'; yield 0; })());
+
+// Multi-value result must be iterable.
+expectMultiValueError(() => 1, TypeError, /iterable/);
+expectMultiValueError(() => 1n, TypeError, /iterable/);
+
+// Check that the iterator's values are collected first, and that the
+// length of the result is correct.
+expectMultiValueError(() => [1], TypeError, /expected 3, got 1/);
+expectMultiValueError(() => [1n], TypeError, /expected 3, got 1/);
+expectMultiValueError(() => [52, 10, 0, 0], TypeError, /expected 3, got 4/);
+expectMultiValueError(() => (function*() { yield 52; yield 10; yield 0; yield 0; })(),
+                      TypeError, /expected 3, got 4/);
+
+// Check that side effects from conversions are done in order.
+{
+    let calls = [];
+    function log(x) { calls.push(x); return x; }
+    function logged(x) { return { valueOf: () => log(x) } }
+    expectMultiValuePass(() => [logged(52), logged(10), logged(0)]);
+    assertEq(calls.join(','), '52,10,0');
+}
+
+function expectMultiValueResult(text, expected) {
+    let instance = wasmEvalText(text);
+    assertDeepEq(instance.exports.run(), expected);
+}
+
+expectMultiValueResult(`
+  (module
+    (func (export "run") (result i32 i32 i32)
+      (i32.const 0)
+      (i32.const 52)
+      (i32.const 10)))`, [0, 52, 10]);
+expectMultiValueResult(`
+  (module
+    (func (export "run") (result f32 f32 f32)
+      (f32.const 0.5)
+      (f32.const 52.5)
+      (f32.const 10.5)))`, [0.5, 52.5, 10.5]);
+expectMultiValueResult(`
+  (module
+    (func (export "run") (result f64 f64 f64)
+      (f64.const 0.5)
+      (f64.const 52.5)
+      (f64.const 10.5)))`, [0.5, 52.5, 10.5]);
+
+expectMultiValueResult(`
+  (module
+    (func (export "run") (result i32 i64 i32)
+      (i32.const 0)
+      (i64.const 52)
+      (i32.const 10)))`, [0, 52n, 10]);
+expectMultiValueResult(`
+  (module
+    (func (export "run") (result i64 i32 i64)
+      (i64.const 0)
+      (i32.const 52)
+      (i64.const 10)))`, [0n, 52, 10n]);
+expectMultiValueResult(`
+  (module
+    (func (export "run") (result i64 i64 i64)
+      (i64.const 0)
+      (i64.const 52)
+      (i64.const 10)))`, [0n, 52n, 10n]);
diff --git a/js/src/jit-test/tests/wasm/multi-value/call-ref.js b/js/src/jit-test/tests/wasm/multi-value/call-ref.js
new file mode 100644
index 0000000000..63b7eb271b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/call-ref.js
@@ -0,0 +1,81 @@
+let counter;
+function resetCounter() { counter = 0; }
+
+function boxNextInt() { return {val: counter++}; }
+function unboxInt(box) { return box.val; }
+function boxNextThreeInts() {
+    return [boxNextInt(), boxNextInt(), boxNextInt()];
+}
+function unboxThreeInts(x, y, z) {
+    return [unboxInt(x), unboxInt(y), unboxInt(z)];
+}
+
+function testAddNextThreeIntsInner(addNextThreeInts) {
+    resetCounter();
+    for (let n = 0; n < 100000; n += 3) {
+        assertEq(addNextThreeInts(), n * 3 + 3);
+    }
+}
+
+function testAddNextThreeInts(text, imports) {
+    let i = new WebAssembly.Instance(
+        new WebAssembly.Module(wasmTextToBinary(text)), { imports });
+
+    testAddNextThreeIntsInner(() => i.exports.addNextThreeInts());
+}
+
+testAddNextThreeInts(`
+      (module
+        (func $boxNextInt (import "imports" "boxNextInt")
+          (result externref))
+        (func $unboxInt (import "imports" "unboxInt")
+          (param externref) (result i32))
+
+        (func $boxNextThreeInts (result externref externref externref)
+          call $boxNextInt
+          call $boxNextInt
+          call $boxNextInt)
+
+        (func $unboxThreeInts (param externref externref externref) (result i32 i32 i32)
+          local.get 0
+          call $unboxInt
+          local.get 1
+          call $unboxInt
+          local.get 2
+          call $unboxInt)
+
+        (func $addNextThreeInts (export "addNextThreeInts") (result i32)
+          call $boxNextThreeInts
+          call $unboxThreeInts
+          i32.add
+          i32.add))`,
+                   {boxNextInt, unboxInt});
+
+testAddNextThreeInts(`
+      (module
+        (func $boxNextThreeInts (import "imports" "boxNextThreeInts")
+          (result externref externref externref))
+        (func $unboxThreeInts (import "imports" "unboxThreeInts")
+          (param externref externref externref) (result i32 i32 i32))
+
+        (func $addNextThreeInts (export "addNextThreeInts") (result i32)
+          call $boxNextThreeInts
+          call $unboxThreeInts
+          i32.add
+          i32.add))`,
+                   {boxNextThreeInts, unboxThreeInts});
+
+{
+    let i = wasmEvalText(`
+      (module
+        (func $boxNextThreeInts (import "imports" "boxNextThreeInts")
+          (result externref externref externref))
+
+        (func (export "boxNextThreeInts") (result externref externref externref)
+          call $boxNextThreeInts))`,
+                         {imports: {boxNextThreeInts}});
+    testAddNextThreeIntsInner(() => {
+        let [a, b, c] = i.exports.boxNextThreeInts();
+        return unboxInt(a) + unboxInt(b) + unboxInt(c);
+    });
+}
diff --git a/js/src/jit-test/tests/wasm/multi-value/call-run.js b/js/src/jit-test/tests/wasm/multi-value/call-run.js
new file mode 100644
index 0000000000..67662a4af5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/call-run.js
@@ -0,0 +1,120 @@
+wasmFullPass(`
+  (module
+    (func (result i32 i32)
+      (i32.const 52)
+      (i32.const 10))
+    (func (export "run") (result i32)
+      (call 0)
+      i32.sub))`,
+            42);
+
+wasmFullPass(`
+  (module
+    (func (param i32 i32) (result i32 i32)
+      (local.get 0)
+      (local.get 1))
+    (func (export "run") (result i32)
+      (i32.const 52)
+      (i32.const 10)
+      (call 0)
+      i32.sub))`,
+            42);
+
+wasmFullPass(`
+  (module
+    (func (param i32 i32 i32 i32 i32
+                 i32 i32 i32 i32 i32)
+          (result i32 i32)
+      (local.get 8)
+      (local.get 9))
+    (func (export "run") (result i32)
+      (i32.const 0)
+      (i32.const 1)
+      (i32.const 2)
+      (i32.const 3)
+      (i32.const 4)
+      (i32.const 5)
+      (i32.const 6)
+      (i32.const 7)
+      (i32.const 52)
+      (i32.const 10)
+      (call 0)
+      i32.sub))`,
+            42);
+
+wasmFullPass(`
+  (module
+    (func (param i32 i32 i32 i32 i32
+                 i32 i32 i32 i32 i32)
+          (result i32 i32)
+      (local i32 i32 i32 i32)
+      (local.get 8)
+      (local.get 9))
+    (func (export "run") (result i32)
+      (i32.const 0)
+      (i32.const 1)
+      (i32.const 2)
+      (i32.const 3)
+      (i32.const 4)
+      (i32.const 5)
+      (i32.const 6)
+      (i32.const 7)
+      (i32.const 52)
+      (i32.const 10)
+      (call 0)
+      i32.sub))`,
+            42);
+
+wasmFullPass(`
+  (module
+    (func (param i32 i32 i32 i32 i32
+                 i32 i32 i32 i32 i32)
+          (result i32 i32 i32)
+      (local i32 i32 i32 i32)
+      (local.get 7)
+      (local.get 8)
+      (local.get 9))
+    (func (export "run") (result i32)
+      (i32.const 0)
+      (i32.const 1)
+      (i32.const 2)
+      (i32.const 3)
+      (i32.const 4)
+      (i32.const 5)
+      (i32.const 6)
+      (i32.const 7)
+      (i32.const 52)
+      (i32.const 10)
+      (call 0)
+      i32.sub
+      i32.sub))`,
+            -35);
+
+wasmFullPass(`
+  (module
+    (func (param i32 i64 i32 i64 i32
+                 i64 i32 i64 i32 i64)
+          (result i64 i32 i64)
+      (local i32 i64 i32 i64)
+      (local.get 7)
+      (local.get 8)
+      (local.get 9))
+    (func (export "run") (result i32)
+      (i32.const 0)
+      (i64.const 1)
+      (i32.const 2)
+      (i64.const 3)
+      (i32.const 4)
+      (i64.const 5)
+      (i32.const 6)
+      (i64.const 7)
+      (i32.const 52)
+      (i64.const 10)
+      (call 0)
+      i32.wrap_i64
+      i32.sub
+      i64.extend_i32_s
+      i64.sub
+      i32.wrap_i64))`,
+            -35);
+
diff --git a/js/src/jit-test/tests/wasm/multi-value/call-validate.js b/js/src/jit-test/tests/wasm/multi-value/call-validate.js
new file mode 100644
index 0000000000..513e11bc6e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/call-validate.js
@@ -0,0 +1,47 @@
+wasmValidateText(`
+  (module
+    (func (result i32 i32)
+      (i32.const 32)
+      (i32.const 10)))`);
+
+wasmValidateText(`
+  (module
+    (type $t (func (result i32 i32)))
+    (func (type $t)
+      (i32.const 32)
+      (i32.const 10)))`);
+
+wasmValidateText(`
+  (module
+    (func (result i32 i32)
+      (block (result i32 i32)
+        (i32.const 32)
+        (i32.const 10))))`);
+
+wasmValidateText(`
+  (module
+    (func $return-2 (result i32 i32)
+      (i32.const 32)
+      (i32.const 10))
+    (func $tail-call (result i32 i32)
+      (call 0)))`);
+
+wasmValidateText(`
+  (module
+    (func $return-2 (result i32 i32)
+      (i32.const 32)
+      (i32.const 10))
+    (func $add (result i32)
+      (call 0)
+      i32.add))`);
+
+wasmValidateText(`
+  (module
+    (func $return-2 (param i32 i32) (result i32 i32)
+      (local.get 0)
+      (local.get 1))
+    (func (export "run") (result i32)
+      (i32.const 32)
+      (i32.const 10)
+      (call 0)
+      i32.add))`);
diff --git a/js/src/jit-test/tests/wasm/multi-value/directives.txt b/js/src/jit-test/tests/wasm/multi-value/directives.txt
new file mode 100644
index 0000000000..f636e648ec
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/multi-value/ion-inlining.js b/js/src/jit-test/tests/wasm/multi-value/ion-inlining.js
new file mode 100644
index 0000000000..0d9a05214e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/ion-inlining.js
@@ -0,0 +1,14 @@
+
+let instance = wasmEvalText(`
+   (module
+     (func $f (export "f") (result i32 i32 i32)
+       (i32.const 0)
+       (i32.const 32)
+       (i32.const 10)))`);
+
+const options = getJitCompilerOptions();
+const jitThreshold = options['ion.warmup.trigger'] * 2 + 2;
+
+for (let i = 0; i < jitThreshold; i++) {
+    assertDeepEq(instance.exports.f(), [0, 32, 10]);
+}
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1597200.js b/js/src/jit-test/tests/wasm/multi-value/regress-1597200.js
new file mode 100644
index 0000000000..542bd542ab
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1597200.js
@@ -0,0 +1,41 @@
+new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (export "main") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (i32.const 3)
+    (loop (param i32 i32 i32)
+      (i32.popcnt)
+      (i32.const -63)
+      (br 0))
+    (unreachable)))`)));
+
+wasmFullPass(`
+(module
+  (func (export "run") (result i32)
+    (block (result i32 i32 i32)
+      (i32.const 41)
+      (i32.const 42)
+      (i32.const 43)
+      (loop (param i32 i32 i32)
+        (i32.eqz)
+        (i32.const -63)
+        (br 1))
+      (unreachable))
+    (drop)
+    (drop)))`,
+            42);
+
+wasmFullPass(`
+(module
+  (func (export "run") (result i32)
+    (block (result i32 i32 i32)
+      (i32.popcnt (i32.const 0x0))
+      (i32.popcnt (i32.const 0xf))
+      (i32.popcnt (i32.const 0xff))
+      (i32.popcnt (i32.const 0xfff))
+      (block) ;; Force a sync().
+      (br 0))
+    (drop)
+    (drop)))`,
+             4);
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1621645-2.js b/js/src/jit-test/tests/wasm/multi-value/regress-1621645-2.js
new file mode 100644
index 0000000000..4ba4b3b116
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1621645-2.js
@@ -0,0 +1,19 @@
+wasmFullPass(`
+  ;; Iterative factorial without locals.
+  (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 (export "run") (param i64) (result i64)
+    (i64.const 1) (local.get 0)
+    (loop $l (param i64 i64) (result i64)
+      (call $pick1) (call $pick1) (i64.mul)
+      (call $pick1) (i64.const 1) (i64.sub)
+      (call $pick0) (i64.const 0) (i64.gt_u)
+      (br_if $l)
+      (drop) (return)
+    )
+  )`,
+             7034535277573963776n, {}, 25n);
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1621645.js b/js/src/jit-test/tests/wasm/multi-value/regress-1621645.js
new file mode 100644
index 0000000000..dc9aaf264c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1621645.js
@@ -0,0 +1,20 @@
+wasmFullPass(`
+(module
+  (func $f (result i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64)
+    (i64.const 0)
+    (i64.const 1)
+    (i64.const 2)
+    (i64.const 3)
+    (i64.const 4)
+    (i64.const 5)
+    (i64.const 6)
+    (i64.const 7)
+    (i64.const 8)
+    (i64.const 9))
+  (func (export "run") (result i32)
+    (call $f)
+    (i64.add) (i64.add) (i64.add) (i64.add) (i64.add)
+    (i64.add) (i64.add) (i64.add) (i64.add)
+    (i32.wrap_i64)))`,
+            45);
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1628417.js b/js/src/jit-test/tests/wasm/multi-value/regress-1628417.js
new file mode 100644
index 0000000000..eb97b2116f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1628417.js
@@ -0,0 +1,11 @@
+let bytes = wasmTextToBinary(`
+   (module
+     (func $main (export "main") (result i32 i32)
+       (i32.const 1)
+       (i32.const 2)
+       (i32.const 0)
+       (br_table 0 0)))`);
+
+let instance = new WebAssembly.Instance(new WebAssembly.Module(bytes));
+
+instance.exports.main();
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1628426.js b/js/src/jit-test/tests/wasm/multi-value/regress-1628426.js
new file mode 100644
index 0000000000..ffb13333c4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1628426.js
@@ -0,0 +1,22 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+var g20 = newGlobal({
+    newCompartment: true
+});
+g20.parent = this;
+g20.eval("Debugger(parent).onEnterFrame = function() {};");
+
+let bytes = wasmTextToBinary(`
+   (module
+     (func $dup (param i32) (result i32 i32)
+       (local.get 0)
+       (local.get 0)
+       (i32.const 2)
+       (i32.mul))
+     (func $main (export "main") (param i32 i32) (result i32)
+       (local.get 1)
+       (call $dup)
+       (i32.sub)))`);
+
+let instance = new WebAssembly.Instance(new WebAssembly.Module(bytes));
+
+assertEq(instance.exports.main(0, 1), -1)
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1628429.js b/js/src/jit-test/tests/wasm/multi-value/regress-1628429.js
new file mode 100644
index 0000000000..3446e0bc8b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1628429.js
@@ -0,0 +1,6 @@
+let bytes = wasmTextToBinary(`
+   (module
+     (func $f (import "imports" "f") (param i32 i32) (result i32 i32)))`);
+
+new WebAssembly.Instance(new WebAssembly.Module(bytes),
+                         { 'imports': { 'f': Uint16Array } });
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1628499.js b/js/src/jit-test/tests/wasm/multi-value/regress-1628499.js
new file mode 100644
index 0000000000..e4360fcb9c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1628499.js
@@ -0,0 +1,11 @@
+let instance = wasmEvalText(`
+  (func $twoRefs (result externref externref)
+    (ref.null extern)
+    (ref.null extern))
+  (func $fourRefs (export "run") (result externref externref externref externref externref externref)
+    call $twoRefs
+    call $twoRefs
+    call $twoRefs)
+`);
+
+assertDeepEq(instance.exports.run(), [null, null, null, null, null, null])
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1629496.js b/js/src/jit-test/tests/wasm/multi-value/regress-1629496.js
new file mode 100644
index 0000000000..220fcf8d3d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1629496.js
@@ -0,0 +1,9 @@
+let bytes = wasmTextToBinary(`
+  (module
+    (func $f (param) (result i32 i32)
+      (local i32)
+      (loop)
+      (i32.const 0)
+      (i32.const 1)))`);
+
+new WebAssembly.Instance(new WebAssembly.Module(bytes));
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1631423.js b/js/src/jit-test/tests/wasm/multi-value/regress-1631423.js
new file mode 100644
index 0000000000..2460830dfd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1631423.js
@@ -0,0 +1,15 @@
+wasmEvalText(`
+    (module
+      (func $main (export "main")
+        (local i32)
+        i32.const 1
+        i32.const 2
+        i32.const 3
+        (loop (param i32 i32 i32)
+          local.get 0
+          i32.const 4
+          i32.const 5
+          i32.const 6
+          i32.const 7
+          br_if 0
+          unreachable)))`);
diff --git a/js/src/jit-test/tests/wasm/multi-value/regress-1661723.js b/js/src/jit-test/tests/wasm/multi-value/regress-1661723.js
new file mode 100644
index 0000000000..3248c13444
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/multi-value/regress-1661723.js
@@ -0,0 +1,23 @@
+let { exports } = new WebAssembly.Instance(
+    new WebAssembly.Module(wasmTextToBinary(`
+    (module
+        (func (import "module" "fn") (param f64 i32) (result i32 f64))
+        (func (export "f") (result i32)
+            f64.const 4.2
+            i32.const 7
+            call 0
+            drop
+        )
+    )
+    `)),
+    {
+        "module": {
+          fn(f32, i32) {
+            assertEq(f32, 4.2);
+            assertEq(i32, 7);
+            return [2, 7.3];
+          },
+        }
+    });
+
+assertEq(exports.f(), 2);
diff --git a/js/src/jit-test/tests/wasm/name.js b/js/src/jit-test/tests/wasm/name.js
new file mode 100644
index 0000000000..ce61eb032b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/name.js
@@ -0,0 +1,20 @@
+// An export name may contain a null terminator
+let exports = wasmEvalText(`(module
+	(func)
+	(export "\\00first" (func 0))
+	(export "\\00second" (func 0))
+)`).exports;
+assertEq(exports["\0first"] instanceof Function, true);
+assertEq(exports["\0second"] instanceof Function, true);
+
+// An import name may contain a null terminator
+let imports = {
+	"\0module": {
+		"\0field": 10,
+	}
+};
+let {global} = wasmEvalText(`(module
+	(import "\\00module" "\\00field" (global i32))
+	(export "global" (global 0))
+)`, imports).exports;
+assertEq(global.value, 10);
diff --git a/js/src/jit-test/tests/wasm/nan-semantics.js b/js/src/jit-test/tests/wasm/nan-semantics.js
new file mode 100644
index 0000000000..b2a8587a4f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/nan-semantics.js
@@ -0,0 +1,199 @@
+var f64 = new Float64Array(2);
+var f32 = new Float32Array(f64.buffer);
+var u8 = new Uint8Array(f64.buffer);
+
+function assertSameBitPattern(from, to, offset) {
+    for (let i = from; i < to; i++)
+        assertEq(u8[i], u8[i + offset], 'non equality in assertSameBitPattern');
+}
+
+// Check that custom NaN can't escape to normal JS, in non-testing mode.
+f32[0] = NaN;
+f32[0] = f32[0]; // Force canonicalization.
+
+f32[1] = wasmEvalText(`
+(module
+  (func (result f32)
+    (f32.const nan:0x123456))
+  (export "" (func 0)))
+`).exports[""]();
+assertSameBitPattern(0, 4, 4);
+
+var checkBitPatterns = {
+    "": {
+        float32(x) {
+            f32[1] = x;
+            assertSameBitPattern(0, 4, 4);
+        },
+        float64(x) {
+            f64[1] = x;
+            assertSameBitPattern(0, 8, 8);
+        }
+    }
+}
+
+wasmEvalText(`
+(module
+  (import "" "float32" (func (param f32)))
+  (func
+    (call 0 (f32.const nan:0x123456)))
+  (export "" (func 0)))
+`, checkBitPatterns).exports[""]();
+
+f64[0] = NaN;
+f64[0] = f64[0]; // Force canonicalization.
+f64[1] = wasmEvalText(`
+(module
+  (func (result f64)
+    (f64.const nan:0x123456))
+  (export "" (func 0)))
+`).exports[""]();
+assertSameBitPattern(0, 8, 8);
+
+wasmEvalText(`
+(module
+  (import "" "float64" (func (param f64)))
+  (func
+    (call 0 (f64.const nan:0x123456)))
+  (export "" (func 0)))
+`, checkBitPatterns).exports[""]();
+
+// SANITY CHECKS
+
+// There are two kinds of NaNs: signaling and quiet. Usually, the first bit of
+// the payload is used to indicate whether it is quiet (1 for quiet, 0 for
+// signaling). Most operations have to transform a signaling NaN into a quiet
+// NaN, which prevents some optimizations in WebAssembly.
+
+// A float32 has 32 bits, 23 bits of them being reserved for the mantissa
+// (= NaN payload).
+var f32_qnan_code = '(f32.const nan:0x600000)';
+var f32_snan_code = '(f32.const nan:0x200000)';
+
+var f32_snan = '0x7fa00000';
+var f32_qnan = '0x7fe00000';
+
+// A float64 has 64 bits, 1 for the sign, 11 for the exponent, the rest for the
+// mantissa (payload).
+var f64_nan_base_high = 0x7ff00000;
+
+var f64_snan_code = '(f64.const nan:0x4000000000000)';
+var f64_qnan_code = '(f64.const nan:0xc000000000000)';
+
+var f64_snan = '0x7ff4000000000000';
+var f64_qnan = '0x7ffc000000000000';
+
+wasmAssert(`(module
+    (func $f32_snan (result f32) ${f32_snan_code})
+    (func $f32_qnan (result f32) ${f32_qnan_code})
+    (func $f64_snan (result f64) ${f64_snan_code})
+    (func $f64_qnan (result f64) ${f64_qnan_code})
+)`, [
+    { type: 'f32', func: '$f32_snan', expected: f32_snan },
+    { type: 'f32', func: '$f32_qnan', expected: f32_qnan },
+    { type: 'f64', func: '$f64_snan', expected: f64_snan },
+    { type: 'f64', func: '$f64_qnan', expected: f64_qnan },
+]);
+
+// Actual tests.
+
+// Wasm spec v1.1 section 4.3.3, sections "fadd" et seq and "NaN propagation":
+// If the input NaN is not canonical then the output may be any arithmetic NaN,
+// ie a quiet NaN with arbitrary payload.
+
+wasmAssert(`(module
+    (global (mut f32) (f32.const 0))
+    (global (mut f64) (f64.const 0))
+
+    ;; An example where a signaling nan gets transformed into a quiet nan:
+    ;; snan + 0.0 = qnan
+    (func $add (result f32) (f32.add ${f32_snan_code} (f32.const 0)))
+
+    ;; Shouldn't affect NaNess.
+    (func $global.set.get_f32 (result f32)
+        ${f32_snan_code}
+        global.set 0
+        global.get 0
+    )
+
+    ;; Shouldn't affect NaNess.
+    (func $global.set.get_f64 (result f64)
+        ${f64_snan_code}
+        global.set 1
+        global.get 1
+    )
+)`, [
+    { type: 'f32', func: '$add', expected: 'nan:arithmetic' },
+    { type: 'f32', func: '$global.set.get_f32', expected: f32_snan },
+    { type: 'f64', func: '$global.set.get_f64', expected: f64_snan },
+]);
+
+// NaN propagation behavior.
+function test(type, opcode, lhs_code, rhs_code) {
+    let qnan_code = type === 'f32' ? f32_qnan : f64_qnan;
+
+    let t = type;
+    let op = opcode;
+
+    // Test all forms:
+    // - (constant, constant),
+    // - (constant, variable),
+    // - (variable, constant),
+    // - (variable, variable)
+    wasmAssert(`(module
+        (func $1 (result ${t}) (${t}.${op} ${lhs_code} ${rhs_code}))
+        (func $2 (param ${t}) (result ${t}) (${t}.${op} (local.get 0) ${rhs_code}))
+        (func $3 (param ${t}) (result ${t}) (${t}.${op} ${lhs_code} (local.get 0)))
+        (func $4 (param ${t}) (param ${t}) (result ${t}) (${t}.${op} (local.get 0) (local.get 1)))
+    )`, [
+        { type, func: '$1', expected: 'nan:arithmetic' },
+        { type, func: '$2', args: [lhs_code], expected: 'nan:arithmetic' },
+        { type, func: '$3', args: [rhs_code], expected: 'nan:arithmetic' },
+        { type, func: '$4', args: [lhs_code, rhs_code], expected: 'nan:arithmetic' },
+    ]);
+}
+
+var f32_zero = '(f32.const 0)';
+var f64_zero = '(f64.const 0)';
+
+var f32_one = '(f32.const 1)';
+var f64_one = '(f64.const 1)';
+
+var f32_negone = '(f32.const -1)';
+var f64_negone = '(f64.const -1)';
+
+// x - 0.0 doesn't get folded into x:
+test('f32', 'sub', f32_snan_code, f32_zero);
+test('f64', 'sub', f64_snan_code, f64_zero);
+
+// x * 1.0 doesn't get folded into x:
+test('f32', 'mul', f32_snan_code, f32_one);
+test('f32', 'mul', f32_one, f32_snan_code);
+
+test('f64', 'mul', f64_snan_code, f64_one);
+test('f64', 'mul', f64_one, f64_snan_code);
+
+// x * -1.0 doesn't get folded into -x:
+test('f32', 'mul', f32_snan_code, f32_negone);
+test('f32', 'mul', f32_negone, f32_snan_code);
+
+test('f64', 'mul', f64_snan_code, f64_negone);
+test('f64', 'mul', f64_negone, f64_snan_code);
+
+// x / -1.0 doesn't get folded into -1 * x:
+test('f32', 'div', f32_snan_code, f32_negone);
+test('f64', 'div', f64_snan_code, f64_negone);
+
+// min doesn't get folded when one of the operands is a NaN
+test('f32', 'min', f32_snan_code, f32_zero);
+test('f32', 'min', f32_zero, f32_snan_code);
+
+test('f64', 'min', f64_snan_code, f64_zero);
+test('f64', 'min', f64_zero, f64_snan_code);
+
+// ditto for max
+test('f32', 'max', f32_snan_code, f32_zero);
+test('f32', 'max', f32_zero, f32_snan_code);
+
+test('f64', 'max', f64_snan_code, f64_zero);
+test('f64', 'max', f64_zero, f64_snan_code);
diff --git a/js/src/jit-test/tests/wasm/oom/breakpoints.js b/js/src/jit-test/tests/wasm/oom/breakpoints.js
new file mode 100644
index 0000000000..a90f97739a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/oom/breakpoints.js
@@ -0,0 +1,12 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+var dbgGlobal = newGlobal({newCompartment: true});
+var dbg = new dbgGlobal.Debugger();
+dbg.addDebuggee(this);
+
+oomTest(() => {
+  wasmEvalText(`
+    (import "" "" (func $d))
+    (func try call $d end)
+  `);
+});
diff --git a/js/src/jit-test/tests/wasm/oom/directives.txt b/js/src/jit-test/tests/wasm/oom/directives.txt
new file mode 100644
index 0000000000..6c28625dd1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/oom/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/oom/exports.js b/js/src/jit-test/tests/wasm/oom/exports.js
new file mode 100644
index 0000000000..391850fda7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/oom/exports.js
@@ -0,0 +1,11 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+oomTest(() => {
+  let text = `(module
+    (type (func (param i32) (result i32)))
+  )`;
+  let binary = wasmTextToBinary(text);
+  let module = new WebAssembly.Module(binary);
+  let obj = module.exports();
+  assertEq(obj instanceof Object, true);
+});
diff --git a/js/src/jit-test/tests/wasm/oom/jsapi-prototype.js b/js/src/jit-test/tests/wasm/oom/jsapi-prototype.js
new file mode 100644
index 0000000000..4888a70db0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/oom/jsapi-prototype.js
@@ -0,0 +1,29 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+oomTest(() => {
+  let memory = new WebAssembly.Memory({initial: 0});
+  assertEq(Object.getPrototypeOf(memory), WebAssembly.Memory.prototype, "prototype");
+});
+
+oomTest(() => {
+  let global = new WebAssembly.Global({value: 'i32'});
+  assertEq(Object.getPrototypeOf(global), WebAssembly.Global.prototype, "prototype");
+});
+
+oomTest(() => {
+  let table = new WebAssembly.Table({element: 'anyfunc', initial: 0});
+  assertEq(Object.getPrototypeOf(table), WebAssembly.Table.prototype, "prototype");
+});
+
+oomTest(() => {
+  let bytecode = wasmTextToBinary('(module)');
+  let module = new WebAssembly.Module(bytecode);
+  assertEq(Object.getPrototypeOf(module), WebAssembly.Module.prototype, "prototype");
+});
+
+oomTest(() => {
+  let bytecode = wasmTextToBinary('(module)');
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, {});
+  assertEq(Object.getPrototypeOf(instance), WebAssembly.Instance.prototype, "prototype");
+});
diff --git a/js/src/jit-test/tests/wasm/passive-segs-boundary.js b/js/src/jit-test/tests/wasm/passive-segs-boundary.js
new file mode 100644
index 0000000000..18dee4a303
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/passive-segs-boundary.js
@@ -0,0 +1,442 @@
+// Perform a test which,
+//
+// * if errKind is defined, is expected to fail with an exception
+//   characterised by errKind and errText.
+//
+// * if errKind is undefined, is expected to succeed, in which case errKind
+//   and errText are ignored.
+//
+// The function body will be [insn1, insn2] and is constructed according to
+// four booleans:
+//
+// * isMem controls whether the module is constructed with memory or
+//   table initializers.
+//
+// * haveStorage determines whether there is actually a memory or table to
+//   work with.
+//
+// * haveInitA controls whether active initializers are added.
+//
+// * haveInitP controls whether passive initializers are added.
+
+function do_test(insn1, insn2, errKind, errText,
+                 isMem, haveStorage, haveInitA, haveInitP)
+{
+    let preamble;
+    if (isMem) {
+        let mem_def  = haveStorage ? "(memory 1 1)" : "";
+        let mem_ia1  = `(data (i32.const 2) "\\03\\01\\04\\01")`;
+        let mem_ia2  = `(data (i32.const 12) "\\07\\05\\02\\03\\06")`;
+        let mem_ip1  = `(data "\\02\\07\\01\\08")`;
+        let mem_ip2  = `(data "\\05\\09\\02\\07\\06")`;
+        let mem_init = ``;
+        if (haveInitA && haveInitP)
+            mem_init = `${mem_ia1} ${mem_ip1} ${mem_ia2} ${mem_ip2}`;
+        else if (haveInitA && !haveInitP) mem_init = `${mem_ia1} ${mem_ia2}`;
+        else if (!haveInitA && haveInitP) mem_init = `${mem_ip1} ${mem_ip2}`;
+        preamble
+            = `;; -------- Memories --------
+               ${mem_def}
+               ;; -------- Memory initialisers --------
+               ${mem_init}
+              `;
+    } else {
+        let tab_def  = haveStorage ? "(table 30 30 funcref)" : "";
+        let tab_ia1  = `(elem (i32.const 2) 3 1 4 1)`;
+        let tab_ia2  = `(elem (i32.const 12) 7 5 2 3 6)`;
+        let tab_ip1  = `(elem func 2 7 1 8)`;
+        let tab_ip2  = `(elem func 5 9 2 7 6)`;
+        let tab_init = ``;
+        if (haveInitA && haveInitP)
+            tab_init = `${tab_ia1} ${tab_ip1} ${tab_ia2} ${tab_ip2}`;
+        else if (haveInitA && !haveInitP) tab_init = `${tab_ia1} ${tab_ia2}`;
+        else if (!haveInitA && haveInitP) tab_init = `${tab_ip1} ${tab_ip2}`;
+        preamble
+            = `;; -------- Tables --------
+               ${tab_def}
+               ;; -------- Table initialisers --------
+               ${tab_init}
+               ;; ------ Functions (0..9) referred by the table/esegs ------
+               (func (result i32) (i32.const 0))
+               (func (result i32) (i32.const 1))
+               (func (result i32) (i32.const 2))
+               (func (result i32) (i32.const 3))
+               (func (result i32) (i32.const 4))
+               (func (result i32) (i32.const 5))
+               (func (result i32) (i32.const 6))
+               (func (result i32) (i32.const 7))
+               (func (result i32) (i32.const 8))
+               (func (result i32) (i32.const 9))
+              `;
+    }
+
+    let txt = "(module\n" + preamble +
+              `;; -------- testfn --------
+               (func (export "testfn")
+                 ${insn1}
+                 ${insn2}
+               )
+               )`;
+
+    if (!!errKind) {
+        assertErrorMessage(
+            () => {
+                let inst = wasmEvalText(txt);
+                inst.exports.testfn();
+            },
+            errKind,
+            errText
+        );
+    } else {
+        let inst = wasmEvalText(txt);
+        assertEq(undefined, inst.exports.testfn());
+    }
+}
+
+
+// Some handy specialisations of do_test().
+
+function mem_test(insn1, insn2, errKind, errText,
+                  haveStorage=true, haveInitA=true, haveInitP=true) {
+    do_test(insn1, insn2, errKind, errText,
+            /*isMem=*/true, haveStorage, haveInitA, haveInitP);
+}
+
+function mem_test_nofail(insn1, insn2,
+                         haveStorage=true, haveInitA=true, haveInitP=true) {
+    do_test(insn1, insn2, undefined, undefined,
+            /*isMem=*/true, haveStorage, haveInitA, haveInitP);
+}
+
+function tab_test(insn1, insn2, errKind, errText,
+                  haveStorage=true, haveInitA=true, haveInitP=true) {
+    do_test(insn1, insn2, errKind, errText,
+            /*isMem=*/false, haveStorage, haveInitA, haveInitP);
+}
+
+function tab_test_nofail(insn1, insn2,
+                         haveStorage=true, haveInitA=true, haveInitP=true) {
+    do_test(insn1, insn2, undefined, undefined,
+            /*isMem=*/false, haveStorage, haveInitA, haveInitP);
+}
+
+
+//---- memory.{drop,init,copy} -------------------------------------------------
+
+// The tested semantics for memory.drop, in the case where there's no memory,
+// are as follows.  table.drop is analogous.
+//
+// no memory, no data segments:
+//    drop with any args -> fail OOB
+//                          [because there's nothing to drop]
+//
+// no memory, data segments, at least one of which is active:
+//    -> always fails, regardless of insns
+//       [because active segments implicitly reference memory 0]
+//
+// no memory, data segments, all of which are passive:
+//    drop, segment index is OOB -> fail OOB
+//                                  [because it refers to non existent segment]
+//
+//    drop, segment index is IB -> OK
+
+// drop with no memory and no data segments
+mem_test("data.drop 0", "",
+         WebAssembly.CompileError, /(data.drop segment index out of range)|(unknown data segment 0)/,
+         /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/false);
+
+// drop with no memory but with both passive and active segments, ix in range
+// and refers to a passive segment
+mem_test("data.drop 3", "",
+         WebAssembly.CompileError,
+         /active data segment requires a memory section/,
+         /*haveStorage=*/false, /*haveInitA=*/true, /*haveInitP=*/true);
+
+// drop with no memory but with passive segments only, ix out of range
+mem_test("data.drop 2", "",
+         WebAssembly.CompileError, /(data.drop segment index out of range)|(unknown data segment 2)/,
+         /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/true);
+
+// drop with no memory but with passive segments only, ix in range
+mem_test_nofail("data.drop 1", "",
+                /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/true);
+
+
+// init with no memory and no data segs
+mem_test("(memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))", "",
+         WebAssembly.CompileError, /(can't touch memory without memory)|(unknown memory 0)/,
+         /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/false);
+
+// drop with data seg ix out of range
+mem_test("data.drop 4", "",
+         WebAssembly.CompileError, /(data.drop segment index out of range)|(unknown data segment 4)/);
+
+// init with data seg ix out of range
+mem_test("(memory.init 4 (i32.const 1234) (i32.const 1) (i32.const 1))", "",
+         WebAssembly.CompileError, /(memory.init segment index out of range)|(unknown data segment 4)/);
+
+// drop with data seg ix indicating an active segment
+mem_test("data.drop 2", "");
+
+// init with data seg ix indicating an active segment
+mem_test("(memory.init 2 (i32.const 1234) (i32.const 1) (i32.const 1))", "",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init, using a data seg ix more than once is OK
+mem_test_nofail(
+    "(memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))",
+    "(memory.init 1 (i32.const 4321) (i32.const 1) (i32.const 1))");
+
+// drop, then drop
+mem_test("data.drop 1",
+         "data.drop 1");
+
+// drop, then init
+mem_test("data.drop 1",
+         "(memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, but length to copy > len of seg
+mem_test("",
+         "(memory.init 1 (i32.const 1234) (i32.const 0) (i32.const 5))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, but implies copying beyond end of seg
+mem_test("",
+         "(memory.init 1 (i32.const 1234) (i32.const 2) (i32.const 3))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, but implies copying beyond end of dst
+mem_test("",
+         "(memory.init 1 (i32.const 0xFFFE) (i32.const 1) (i32.const 3))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, zero len, but src offset out of bounds at the
+// edge
+mem_test("",
+         "(memory.init 1 (i32.const 1234) (i32.const 4) (i32.const 0))");
+
+// init: seg ix is valid passive, zero len, but src offset out of bounds one
+// past the edge
+mem_test("",
+         "(memory.init 1 (i32.const 1234) (i32.const 5) (i32.const 0))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, zero len, but dst offset out of bounds at the
+// edge
+mem_test("",
+         "(memory.init 1 (i32.const 0x10000) (i32.const 2) (i32.const 0))");
+
+// init: seg ix is valid passive, zero len, but dst offset out of bounds one
+// past the edge
+mem_test("",
+         "(memory.init 1 (i32.const 0x10001) (i32.const 2) (i32.const 0))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// drop: too many args
+mem_test("data.drop 1 (i32.const 42)", "",
+         WebAssembly.CompileError,
+         /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+// init: too many args
+mem_test("(memory.init 1 (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1))",
+         "",
+         WebAssembly.CompileError, /(unused values)|(values remaining on stack at end of block)/);
+
+// init: too few args
+mem_test("(memory.init 1 (i32.const 1) (i32.const 1))", "",
+         WebAssembly.CompileError,
+         /(popping value from empty stack)|(expected i32 but nothing on stack)/);
+
+// invalid argument types
+{
+    const tys  = ['i32', 'f32', 'i64', 'f64'];
+
+    for (let ty1 of tys) {
+    for (let ty2 of tys) {
+    for (let ty3 of tys) {
+        if (ty1 == 'i32' && ty2 == 'i32' && ty3 == 'i32')
+            continue;  // this is the only valid case
+        let i1 = `(memory.init 1 (${ty1}.const 1) (${ty2}.const 1) (${ty3}.const 1))`;
+        mem_test(i1, "", WebAssembly.CompileError, /type mismatch/);
+    }}}
+}
+
+//
+//---- table.{drop,init} --------------------------------------------------
+
+// drop with no tables and no elem segments
+tab_test("elem.drop 0", "",
+         WebAssembly.CompileError,
+         /(element segment index out of range for elem.drop)|(segment index out of bounds)/,
+         /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/false);
+
+// drop with no tables but with both passive and active segments, ix in range
+// and refers to a passive segment
+tab_test("elem.drop 3", "",
+         WebAssembly.CompileError,
+         /active elem segment requires a table/,
+         /*haveStorage=*/false, /*haveInitA=*/true, /*haveInitP=*/true);
+
+// drop with no tables but with passive segments only, ix out of range
+tab_test("elem.drop 2", "",
+         WebAssembly.CompileError,
+         /(element segment index out of range for elem.drop)|(segment index out of bounds)/,
+         /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/true);
+
+// drop with no tables but with passive segments only, ix in range
+tab_test_nofail("elem.drop 1", "",
+                /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/true);
+
+
+// init with no table
+tab_test("(table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))", "",
+         WebAssembly.CompileError, /(table index out of range)|(table index out of bounds)/,
+         /*haveStorage=*/false, /*haveInitA=*/false, /*haveInitP=*/false);
+
+// drop with elem seg ix out of range
+tab_test("elem.drop 4", "",
+         WebAssembly.CompileError, /(element segment index out of range for elem.drop)|(segment index out of bounds)/);
+
+// init with elem seg ix out of range
+tab_test("(table.init 4 (i32.const 12) (i32.const 1) (i32.const 1))", "",
+         WebAssembly.CompileError, /(table.init segment index out of range)|(segment index out of bounds)/);
+
+// drop with elem seg ix indicating an active segment
+tab_test("elem.drop 2", "");
+
+// init with elem seg ix indicating an active segment
+tab_test("(table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))", "",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init, using an elem seg ix more than once is OK
+tab_test_nofail(
+    "(table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))",
+    "(table.init 1 (i32.const 21) (i32.const 1) (i32.const 1))");
+
+// drop, then drop
+tab_test("elem.drop 1",
+         "elem.drop 1");
+
+// drop, then init
+tab_test("elem.drop 1",
+         "(table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, but length to copy > len of seg
+tab_test("",
+         "(table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, but implies copying beyond end of seg
+tab_test("",
+         "(table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, but implies copying beyond end of dst
+tab_test("",
+         "(table.init 1 (i32.const 28) (i32.const 1) (i32.const 3))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, zero len, but src offset out of bounds at the
+// edge
+tab_test("",
+         "(table.init 1 (i32.const 12) (i32.const 4) (i32.const 0))");
+
+// init: seg ix is valid passive, zero len, but src offset out of bounds one
+// past the edge
+tab_test("",
+         "(table.init 1 (i32.const 12) (i32.const 5) (i32.const 0))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// init: seg ix is valid passive, zero len, but dst offset out of bounds
+tab_test("",
+         "(table.init 1 (i32.const 30) (i32.const 2) (i32.const 0))");
+
+// init: seg ix is valid passive, zero len, but dst offset out of bounds one
+// past the edge
+tab_test("",
+         "(table.init 1 (i32.const 31) (i32.const 2) (i32.const 0))",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// drop: too many args
+tab_test("elem.drop 1 (i32.const 42)", "",
+         WebAssembly.CompileError,
+         /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+// init: too many args
+tab_test("(table.init 1 (i32.const 1) (i32.const 1) (i32.const 1) (i32.const 1))",
+         "",
+         WebAssembly.CompileError, /(unused values)|(values remaining on stack at end of block)/);
+
+// init: too few args
+tab_test("(table.init 1 (i32.const 1) (i32.const 1))", "",
+         WebAssembly.CompileError,
+         /(popping value from empty stack)|(expected i32 but nothing on stack)/);
+
+// invalid argument types
+{
+    const tys  = ['i32', 'f32', 'i64', 'f64'];
+
+    const ops = ['table.init 1', 'table.copy'];
+    for (let ty1 of tys) {
+    for (let ty2 of tys) {
+    for (let ty3 of tys) {
+    for (let op of ops) {
+        if (ty1 == 'i32' && ty2 == 'i32' && ty3 == 'i32')
+            continue;  // this is the only valid case
+        let i1 = `(${op} (${ty1}.const 1) (${ty2}.const 1) (${ty3}.const 1))`;
+        tab_test(i1, "", WebAssembly.CompileError, /type mismatch/);
+    }}}}
+}
+
+
+//---- table.copy ---------------------------------------------------------
+
+// There are no immediates here, only 3 dynamic args.  So we're limited to
+// runtime boundary checks.
+
+// passive-segs-smoketest.js tests the normal, non-exception cases of
+// table.copy.  Here we just test the boundary-failure cases.  The
+// table's valid indices are 0 .. 29 inclusive.
+
+// copy: dst range invalid
+tab_test("(table.copy (i32.const 28) (i32.const 1) (i32.const 3))",
+         "",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// copy: dst wraparound end of 32 bit offset space
+tab_test("(table.copy (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))",
+         "",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// copy: src range invalid
+tab_test("(table.copy (i32.const 15) (i32.const 25) (i32.const 6))",
+         "",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// copy: src wraparound end of 32 bit offset space
+tab_test("(table.copy (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))",
+         "",
+         WebAssembly.RuntimeError, /index out of bounds/);
+
+// copy: zero length with both offsets in-bounds is OK
+tab_test_nofail(
+    "(table.copy (i32.const 15) (i32.const 25) (i32.const 0))",
+    "");
+
+// copy: zero length with dst offset out of bounds at the edge
+tab_test("(table.copy (i32.const 30) (i32.const 15) (i32.const 0))",
+         "");
+
+// copy: zero length with dst offset out of bounds one past the edge
+tab_test("(table.copy (i32.const 31) (i32.const 15) (i32.const 0))",
+         "", WebAssembly.RuntimeError, /index out of bounds/);
+
+// copy: zero length with src offset out of bounds at the edge
+tab_test("(table.copy (i32.const 15) (i32.const 30) (i32.const 0))",
+         "");
+
+// copy: zero length with src offset out of bounds one past the edge
+tab_test("(table.copy (i32.const 15) (i32.const 31) (i32.const 0))",
+         "", WebAssembly.RuntimeError, /index out of bounds/);
diff --git a/js/src/jit-test/tests/wasm/passive-segs-nonboundary.js b/js/src/jit-test/tests/wasm/passive-segs-nonboundary.js
new file mode 100644
index 0000000000..6753355e1e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/passive-segs-nonboundary.js
@@ -0,0 +1,1188 @@
+load(libdir + "wasm-binary.js");
+
+const v2vSig = {args:[], ret:VoidCode};
+const v2vSigSection = sigSection([v2vSig]);
+
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+
+// Some non-boundary tests for {table,memory}.{init,drop,copy}.  The table
+// case is more complex and appears first.  The memory case is a simplified
+// version of it.
+
+// This module exports 5 functions ..
+let tab_expmod_t =
+    `(module
+        (func (export "ef0") (result i32) (i32.const 0))
+        (func (export "ef1") (result i32) (i32.const 1))
+        (func (export "ef2") (result i32) (i32.const 2))
+        (func (export "ef3") (result i32) (i32.const 3))
+        (func (export "ef4") (result i32) (i32.const 4))
+     )`;
+
+// .. and this one imports those 5 functions.  It adds 5 of its own, creates a
+// 30 element table using both active and passive initialisers, with a mixture
+// of the imported and local functions.  |setup| and |check| are exported.
+// |setup| uses the supplied |insn| to modify the table somehow.  |check| will
+// indirect-call the table entry number specified as a parameter.  That will
+// either return a value 0 to 9 indicating the function called, or will throw an
+// exception if the table entry is empty.
+function gen_tab_impmod_t(insn)
+{
+  let t =
+  `(module
+     ;; -------- Types --------
+     (type (func (result i32)))  ;; type #0
+     ;; -------- Imports --------
+     (import "a" "if0" (func (result i32)))    ;; index 0
+     (import "a" "if1" (func (result i32)))
+     (import "a" "if2" (func (result i32)))
+     (import "a" "if3" (func (result i32)))
+     (import "a" "if4" (func (result i32)))    ;; index 4
+     ;; -------- Tables --------
+     (table 30 30 funcref)
+     ;; -------- Table initialisers --------
+     (elem (i32.const 2) 3 1 4 1)
+     (elem func 2 7 1 8)
+     (elem (i32.const 12) 7 5 2 3 6)
+     (elem func 5 9 2 7 6)
+     ;; -------- Functions --------
+     (func (result i32) (i32.const 5))  ;; index 5
+     (func (result i32) (i32.const 6))
+     (func (result i32) (i32.const 7))
+     (func (result i32) (i32.const 8))
+     (func (result i32) (i32.const 9))  ;; index 9
+
+     (func (export "setup")
+       ${insn})
+     (func (export "check") (param i32) (result i32)
+       ;; call the selected table entry, which will either return a value,
+       ;; or will cause an exception.
+       local.get 0      ;; callIx
+       call_indirect (type 0)  ;; and its return value is our return value.
+     )
+   )`;
+   return t;
+};
+
+// This is the test driver.  It constructs the abovementioned module, using
+// the given |instruction| to modify the table, and then probes the table
+// by making indirect calls, one for each element of |expected_result_vector|.
+// The results are compared to those in the vector.
+
+function tab_test(instruction, expected_result_vector)
+{
+    let tab_expmod_b = wasmTextToBinary(tab_expmod_t);
+    let tab_expmod_i = new Instance(new Module(tab_expmod_b));
+
+    let tab_impmod_t = gen_tab_impmod_t(instruction);
+    let tab_impmod_b = wasmTextToBinary(tab_impmod_t);
+
+    let inst = new Instance(new Module(tab_impmod_b),
+                            {a:{if0:tab_expmod_i.exports.ef0,
+                                if1:tab_expmod_i.exports.ef1,
+                                if2:tab_expmod_i.exports.ef2,
+                                if3:tab_expmod_i.exports.ef3,
+                                if4:tab_expmod_i.exports.ef4
+                               }});
+    inst.exports.setup();
+
+    for (let i = 0; i < expected_result_vector.length; i++) {
+        let expected = expected_result_vector[i];
+        let actual = undefined;
+        try {
+            actual = inst.exports.check(i);
+            assertEq(actual !== null, true);
+        } catch (e) {
+            if (!(e instanceof Error &&
+                  e.message.match(/indirect call to null/)))
+                throw e;
+            // actual remains undefined
+        }
+        assertEq(actual, expected,
+                 "tab_test fail: insn = '" + instruction + "', index = " +
+                 i + ", expected = " + expected + ", actual = " + actual);
+    }
+}
+
+// Using 'e' for empty (undefined) spaces in the table, to make it easier
+// to count through the vector entries when debugging.
+let e = undefined;
+
+// This just gives the initial state of the table, with its active
+// initialisers applied
+tab_test("nop",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy non-null over non-null
+tab_test("(table.copy (i32.const 13) (i32.const 2) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,3,1, 4,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy non-null over null
+tab_test("(table.copy (i32.const 25) (i32.const 15) (i32.const 2))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, 3,6,e,e,e]);
+
+// Copy null over non-null
+tab_test("(table.copy (i32.const 13) (i32.const 25) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,e,e, e,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy null over null
+tab_test("(table.copy (i32.const 20) (i32.const 22) (i32.const 4))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy null and non-null entries, non overlapping
+tab_test("(table.copy (i32.const 25) (i32.const 1) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,3,1,e,e]);
+
+// Copy null and non-null entries, overlapping, backwards
+tab_test("(table.copy (i32.const 10) (i32.const 12) (i32.const 7))",
+         [e,e,3,1,4, 1,e,e,e,e, 7,5,2,3,6, e,e,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy null and non-null entries, overlapping, forwards
+tab_test("(table.copy (i32.const 12) (i32.const 10) (i32.const 7))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,e,e,7, 5,2,3,6,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Passive init that overwrites all-null entries
+tab_test("(table.init 1 (i32.const 7) (i32.const 0) (i32.const 4))",
+         [e,e,3,1,4, 1,e,2,7,1, 8,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Passive init that overwrites existing active-init-created entries
+tab_test("(table.init 3 (i32.const 15) (i32.const 1) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 9,2,7,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Perform active and passive initialisation and then multiple copies
+tab_test("(table.init 1 (i32.const 7) (i32.const 0) (i32.const 4)) \n" +
+         "elem.drop 1 \n" +
+         "(table.init 3 (i32.const 15) (i32.const 1) (i32.const 3)) \n" +
+         "elem.drop 3 \n" +
+         "(table.copy (i32.const 20) (i32.const 15) (i32.const 5)) \n" +
+         "(table.copy (i32.const 21) (i32.const 29) (i32.const 1)) \n" +
+         "(table.copy (i32.const 24) (i32.const 10) (i32.const 1)) \n" +
+         "(table.copy (i32.const 13) (i32.const 11) (i32.const 4)) \n" +
+         "(table.copy (i32.const 19) (i32.const 20) (i32.const 5))",
+         [e,e,3,1,4, 1,e,2,7,1, 8,e,7,e,7, 5,2,7,e,9, e,7,e,8,8, e,e,e,e,e]);
+
+// And now a simplified version of the above, for memory.{init,drop,copy}.
+
+function gen_mem_mod_t(insn)
+{
+  let t =
+  `(module
+     ;; -------- Memories --------
+     (memory (export "memory0") 1 1)
+     ;; -------- Memory initialisers --------
+     (data (i32.const 2) "\\03\\01\\04\\01")
+     (data "\\02\\07\\01\\08")
+     (data (i32.const 12) "\\07\\05\\02\\03\\06")
+     (data "\\05\\09\\02\\07\\06")
+
+     (func (export "testfn")
+       ${insn}
+       ;; There's no return value.  The JS driver can just pull out the
+       ;; final memory and examine it.
+     )
+   )`;
+   return t;
+};
+
+function mem_test(instruction, expected_result_vector)
+{
+    let mem_mod_t = gen_mem_mod_t(instruction);
+    let mem_mod_b = wasmTextToBinary(mem_mod_t);
+
+    let inst = new Instance(new Module(mem_mod_b));
+    inst.exports.testfn();
+    let buf = new Uint8Array(inst.exports.memory0.buffer);
+
+    for (let i = 0; i < expected_result_vector.length; i++) {
+        let expected = expected_result_vector[i];
+        let actual = buf[i];
+        assertEq(actual, expected,
+                 "mem_test fail: insn = '" + instruction + "', index = " +
+                 i + ", expected = " + expected + ", actual = " + actual);
+    }
+}
+
+e = 0;
+
+// This just gives the initial state of the memory, with its active
+// initialisers applied.
+mem_test("nop",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy non-zero over non-zero
+mem_test("(memory.copy (i32.const 13) (i32.const 2) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,3,1, 4,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy non-zero over zero
+mem_test("(memory.copy (i32.const 25) (i32.const 15) (i32.const 2))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, 3,6,e,e,e]);
+
+// Copy zero over non-zero
+mem_test("(memory.copy (i32.const 13) (i32.const 25) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,e,e, e,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy zero over zero
+mem_test("(memory.copy (i32.const 20) (i32.const 22) (i32.const 4))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy zero and non-zero entries, non overlapping
+mem_test("(memory.copy (i32.const 25) (i32.const 1) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,3,1,e,e]);
+
+// Copy zero and non-zero entries, overlapping, backwards
+mem_test("(memory.copy (i32.const 10) (i32.const 12) (i32.const 7))",
+         [e,e,3,1,4, 1,e,e,e,e, 7,5,2,3,6, e,e,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Copy zero and non-zero entries, overlapping, forwards
+mem_test("(memory.copy (i32.const 12) (i32.const 10) (i32.const 7))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,e,e,7, 5,2,3,6,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Passive init that overwrites all-zero entries
+mem_test("(memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))",
+         [e,e,3,1,4, 1,e,2,7,1, 8,e,7,5,2, 3,6,e,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Passive init that overwrites existing active-init-created entries
+mem_test("(memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))",
+         [e,e,3,1,4, 1,e,e,e,e, e,e,7,5,2, 9,2,7,e,e, e,e,e,e,e, e,e,e,e,e]);
+
+// Perform active and passive initialisation and then multiple copies
+mem_test("(memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)) \n" +
+         "data.drop 1 \n" +
+         "(memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)) \n" +
+         "data.drop 3 \n" +
+         "(memory.copy (i32.const 20) (i32.const 15) (i32.const 5)) \n" +
+         "(memory.copy (i32.const 21) (i32.const 29) (i32.const 1)) \n" +
+         "(memory.copy (i32.const 24) (i32.const 10) (i32.const 1)) \n" +
+         "(memory.copy (i32.const 13) (i32.const 11) (i32.const 4)) \n" +
+         "(memory.copy (i32.const 19) (i32.const 20) (i32.const 5))",
+         [e,e,3,1,4, 1,e,2,7,1, 8,e,7,e,7, 5,2,7,e,9, e,7,e,8,8, e,e,e,e,e]);
+
+function checkDataCount(count, err) {
+    let binary = moduleWithSections(
+        [v2vSigSection,
+         dataCountSection(count),
+         dataSection([
+           {offset: 0, elems: []},
+           {offset: 0, elems: []},
+         ])
+        ]);
+    assertErrorMessage(() => new WebAssembly.Module(binary),
+                       WebAssembly.CompileError,
+                       err);
+}
+
+// DataCount section is present but value is too low for the number of data segments
+checkDataCount(1, /number of data segments does not match declared count/);
+// DataCount section is present but value is too high for the number of data segments
+checkDataCount(3, /number of data segments does not match declared count/);
+
+// DataCount section is not present but memory.init or data.drop uses it
+function checkNoDataCount(body, err) {
+    let binary = moduleWithSections(
+        [v2vSigSection,
+         declSection([0]),
+         memorySection(1),
+         bodySection(
+             [funcBody({locals:[], body})])]);
+    assertErrorMessage(() => new WebAssembly.Module(binary),
+                       WebAssembly.CompileError,
+                       err);
+}
+
+checkNoDataCount([I32ConstCode, 0,
+                  I32ConstCode, 0,
+                  I32ConstCode, 0,
+                  MiscPrefix, MemoryInitCode, 0, 0],
+                /(memory.init requires a DataCount section)|(unknown data segment)/);
+
+checkNoDataCount([MiscPrefix, DataDropCode, 0],
+                 /(data.drop requires a DataCount section)|(unknown data segment)/);
+
+//---------------------------------------------------------------------//
+//---------------------------------------------------------------------//
+// Some further tests for memory.copy and memory.fill.  First, validation
+// tests.
+
+// Prefixed opcodes
+
+function checkMiscPrefixed(opcode, expect_failure) {
+    let binary = moduleWithSections(
+           [v2vSigSection, declSection([0]), memorySection(1),
+            bodySection(
+                [funcBody(
+                    {locals:[],
+                     body:[I32ConstCode, 0x0,
+                           I32ConstCode, 0x0,
+                           I32ConstCode, 0x0,
+                           MiscPrefix, ...opcode]})])]);
+    if (expect_failure) {
+        assertErrorMessage(() => new WebAssembly.Module(binary),
+                           WebAssembly.CompileError, /(unrecognized opcode)|(Unknown.*subopcode)/);
+    } else {
+        assertEq(WebAssembly.validate(binary), true);
+    }
+}
+
+//-----------------------------------------------------------
+// Verification cases for memory.copy/fill opcode encodings
+
+checkMiscPrefixed([MemoryCopyCode, 0x00, 0x00], false); // memory.copy src=0 dest=0
+checkMiscPrefixed([MemoryFillCode, 0x00], false); // memory.fill mem=0
+checkMiscPrefixed([0x13], true);        // table.size+1, which is currently unassigned
+
+//-----------------------------------------------------------
+// Verification cases for memory.copy/fill arguments
+
+// Invalid argument types
+{
+    const tys = ['i32', 'f32', 'i64', 'f64'];
+    const ops = ['copy', 'fill'];
+    for (let ty1 of tys) {
+    for (let ty2 of tys) {
+    for (let ty3 of tys) {
+    for (let op of ops) {
+        if (ty1 == 'i32' && ty2 == 'i32' && ty3 == 'i32')
+            continue;  // this is the only valid case
+        let text =
+        `(module
+          (memory (export "memory") 1 1)
+           (func (export "testfn")
+           (memory.${op} (${ty1}.const 10) (${ty2}.const 20) (${ty3}.const 30))
+          )
+         )`;
+        assertErrorMessage(() => wasmEvalText(text),
+                           WebAssembly.CompileError, /type mismatch/);
+    }}}}
+}
+
+// Not enough, or too many, args
+{
+    for (let op of ['copy', 'fill']) {
+        let text1 =
+        `(module
+          (memory (export "memory") 1 1)
+          (func (export "testfn")
+           (i32.const 10)
+           (i32.const 20)
+           memory.${op}
+         )
+        )`;
+        assertErrorMessage(() => wasmEvalText(text1),
+                           WebAssembly.CompileError,
+                           /(popping value from empty stack)|(expected i32 but nothing on stack)/);
+        let text2 =
+        `(module
+          (memory (export "memory") 1 1)
+          (func (export "testfn")
+           (i32.const 10)
+           (i32.const 20)
+           (i32.const 30)
+           (i32.const 40)
+           memory.${op}
+         )
+        )`;
+        assertErrorMessage(() => wasmEvalText(text2),
+                           WebAssembly.CompileError,
+                           /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+    }
+}
+
+// Module doesn't have a memory
+{
+    for (let op of ['copy', 'fill']) {
+        let text =
+        `(module
+          (func (export "testfn")
+           (memory.${op} (i32.const 10) (i32.const 20) (i32.const 30))
+         )
+        )`;
+        assertErrorMessage(() => wasmEvalText(text),
+                           WebAssembly.CompileError,
+                           /(can't touch memory without memory)|(unknown memory)/);
+    }
+}
+
+//---------------------------------------------------------------------//
+//---------------------------------------------------------------------//
+// Run tests
+
+//-----------------------------------------------------------
+// Test helpers
+function checkRange(arr, minIx, maxIxPlusOne, expectedValue)
+{
+    for (let i = minIx; i < maxIxPlusOne; i++) {
+        assertEq(arr[i], expectedValue);
+    }
+}
+
+//-----------------------------------------------------------
+// Test cases for memory.fill
+
+// Range valid
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0x00000, 0x0FF00, 0x00);
+    checkRange(b, 0x0FF00, 0x10000, 0x55);
+}
+
+// Range invalid
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Wraparound the end of 32-bit offset space
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Zero len with offset in-bounds is a no-op
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0x00000, 0x10000, 0x00);
+}
+
+// Zero len with offset out-of-bounds is OK
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0))
+       )
+     )`
+    );
+    inst.exports.testfn();
+}
+
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0x10001) (i32.const 0x55) (i32.const 0))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Very large range
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0x00000, 0x00001, 0x00);
+    checkRange(b, 0x00001, 0x0FFFF, 0xAA);
+    checkRange(b, 0x0FFFF, 0x10000, 0x00);
+}
+
+// Sequencing
+{
+    let i = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn") (result i32)
+         (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10))
+         (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4))
+         i32.const 99
+       )
+     )`
+    );
+    i.exports.testfn();
+    let b = new Uint8Array(i.exports.memory.buffer);
+    checkRange(b, 0x0,     0x12+0,  0x00);
+    checkRange(b, 0x12+0,  0x12+3,  0x55);
+    checkRange(b, 0x12+3,  0x12+7,  0xAA);
+    checkRange(b, 0x12+7,  0x12+10, 0x55);
+    checkRange(b, 0x12+10, 0x10000, 0x00);
+}
+
+
+//-----------------------------------------------------------
+// Test cases for memory.copy
+
+// Both ranges valid.  Copy 5 bytes backwards by 1 (overlapping).
+// result = 0x00--(09) 0x55--(11) 0x00--(pagesize-20)
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+         (memory.copy (i32.const 9) (i32.const 10) (i32.const 5))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0,    0+9,     0x00);
+    checkRange(b, 9,    9+11,    0x55);
+    checkRange(b, 9+11, 0x10000, 0x00);
+}
+
+// Both ranges valid.  Copy 5 bytes forwards by 1 (overlapping).
+// result = 0x00--(10) 0x55--(11) 0x00--(pagesize-19)
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+         (memory.copy (i32.const 16) (i32.const 15) (i32.const 5))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0,     0+10,    0x00);
+    checkRange(b, 10,    10+11,   0x55);
+    checkRange(b, 10+11, 0x10000, 0x00);
+}
+
+// Destination range invalid
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Destination wraparound the end of 32-bit offset space
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Source range invalid
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Source wraparound the end of 32-bit offset space
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Zero len with both offsets in-bounds is a no-op
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000))
+         (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000))
+         (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0x00000, 0x08000, 0x55);
+    checkRange(b, 0x08000, 0x10000, 0xAA);
+}
+
+// Zero len with dest offset out-of-bounds at the edge of memory
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0))
+       )
+     )`
+    );
+    inst.exports.testfn();
+}
+
+// Ditto, but one element further out
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0x10001) (i32.const 0x7000) (i32.const 0))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// Zero len with src offset out-of-bounds at the edge of memory
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0))
+       )
+     )`
+    );
+    inst.exports.testfn();
+}
+
+// Ditto, but one element further out
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.copy (i32.const 0x9000) (i32.const 0x10001) (i32.const 0))
+       )
+     )`
+    );
+    assertErrorMessage(() => inst.exports.testfn(),
+                       WebAssembly.RuntimeError, /index out of bounds/);
+}
+
+// 100 random fills followed by 100 random copies, in a single-page buffer,
+// followed by verification of the (now heavily mashed-around) buffer.
+{
+    let inst = wasmEvalText(
+    `(module
+       (memory (export "memory") 1 1)
+       (func (export "testfn")
+         (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344))
+         (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055))
+         (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988))
+         (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322))
+         (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994))
+         (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036))
+         (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372))
+         (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835))
+         (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393))
+         (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758))
+         (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098))
+         (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741))
+         (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823))
+         (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280))
+         (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466))
+         (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158))
+         (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544))
+         (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669))
+         (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651))
+         (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570))
+         (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691))
+         (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646))
+         (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858))
+         (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657))
+         (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981))
+         (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807))
+         (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487))
+         (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530))
+         (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943))
+         (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381))
+         (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089))
+         (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658))
+         (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702))
+         (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092))
+         (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410))
+         (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204))
+         (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394))
+         (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250))
+         (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097))
+         (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264))
+         (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299))
+         (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796))
+         (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070))
+         (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763))
+         (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312))
+         (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192))
+         (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596))
+         (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501))
+         (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686))
+         (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385))
+         (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903))
+         (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390))
+         (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441))
+         (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162))
+         (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135))
+         (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519))
+         (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280))
+         (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678))
+         (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168))
+         (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441))
+         (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663))
+         (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671))
+         (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721))
+         (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84))
+         (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029))
+         (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29))
+         (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034))
+         (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043))
+         (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324))
+         (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091))
+         (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997))
+         (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259))
+         (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189))
+         (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968))
+         (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455))
+         (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177))
+         (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568))
+         (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642))
+         (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284))
+         (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223))
+         (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171))
+         (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322))
+         (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648))
+         (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045))
+         (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097))
+         (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796))
+         (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010))
+         (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0))
+         (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069))
+         (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896))
+         (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192))
+         (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195))
+         (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24))
+         (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577))
+         (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089))
+         (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436))
+         (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765))
+         (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830))
+         (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938))
+         (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750))
+         (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098))
+         (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230))
+         (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300))
+         (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639))
+         (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097))
+         (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197))
+         (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100))
+         (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717))
+         (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119))
+         (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658))
+         (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269))
+         (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833))
+         (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300))
+         (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281))
+         (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572))
+         (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328))
+         (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670))
+         (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33))
+         (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427))
+         (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434))
+         (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834))
+         (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317))
+         (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201))
+         (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452))
+         (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346))
+         (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430))
+         (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300))
+         (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153))
+         (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281))
+         (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943))
+         (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887))
+         (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738))
+         (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122))
+         (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755))
+         (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702))
+         (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830))
+         (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064))
+         (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631))
+         (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113))
+         (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975))
+         (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336))
+         (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872))
+         (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197))
+         (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958))
+         (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186))
+         (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037))
+         (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650))
+         (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986))
+         (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955))
+         (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368))
+         (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356))
+         (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382))
+         (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900))
+         (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807))
+         (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323))
+         (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670))
+         (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341))
+         (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644))
+         (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496))
+         (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784))
+         (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350))
+         (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475))
+         (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467))
+         (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895))
+         (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751))
+         (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127))
+         (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063))
+         (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766))
+         (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520))
+         (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014))
+         (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011))
+         (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034))
+         (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320))
+         (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308))
+         (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155))
+         (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722))
+         (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370))
+         (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926))
+         (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607))
+         (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045))
+         (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596))
+         (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168))
+         (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137))
+         (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649))
+         (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52))
+         (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441))
+         (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445))
+         (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785))
+         (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406))
+         (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381))
+         (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136))
+         (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045))
+         (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389))
+         (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877))
+         (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447))
+         (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854))
+         (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377))
+         (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594))
+         (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987))
+         (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406))
+       )
+     )`
+    );
+    inst.exports.testfn();
+    let b = new Uint8Array(inst.exports.memory.buffer);
+    checkRange(b, 0, 124, 0);
+    checkRange(b, 124, 1517, 9);
+    checkRange(b, 1517, 2132, 0);
+    checkRange(b, 2132, 2827, 10);
+    checkRange(b, 2827, 2921, 92);
+    checkRange(b, 2921, 3538, 83);
+    checkRange(b, 3538, 3786, 77);
+    checkRange(b, 3786, 4042, 97);
+    checkRange(b, 4042, 4651, 99);
+    checkRange(b, 4651, 5057, 0);
+    checkRange(b, 5057, 5109, 99);
+    checkRange(b, 5109, 5291, 0);
+    checkRange(b, 5291, 5524, 72);
+    checkRange(b, 5524, 5691, 92);
+    checkRange(b, 5691, 6552, 83);
+    checkRange(b, 6552, 7133, 77);
+    checkRange(b, 7133, 7665, 99);
+    checkRange(b, 7665, 8314, 0);
+    checkRange(b, 8314, 8360, 62);
+    checkRange(b, 8360, 8793, 86);
+    checkRange(b, 8793, 8979, 83);
+    checkRange(b, 8979, 9373, 79);
+    checkRange(b, 9373, 9518, 95);
+    checkRange(b, 9518, 9934, 59);
+    checkRange(b, 9934, 10087, 77);
+    checkRange(b, 10087, 10206, 5);
+    checkRange(b, 10206, 10230, 77);
+    checkRange(b, 10230, 10249, 41);
+    checkRange(b, 10249, 11148, 83);
+    checkRange(b, 11148, 11356, 74);
+    checkRange(b, 11356, 11380, 93);
+    checkRange(b, 11380, 11939, 74);
+    checkRange(b, 11939, 12159, 68);
+    checkRange(b, 12159, 12575, 83);
+    checkRange(b, 12575, 12969, 79);
+    checkRange(b, 12969, 13114, 95);
+    checkRange(b, 13114, 14133, 59);
+    checkRange(b, 14133, 14404, 76);
+    checkRange(b, 14404, 14428, 57);
+    checkRange(b, 14428, 14458, 59);
+    checkRange(b, 14458, 14580, 32);
+    checkRange(b, 14580, 14777, 89);
+    checkRange(b, 14777, 15124, 59);
+    checkRange(b, 15124, 15126, 36);
+    checkRange(b, 15126, 15192, 100);
+    checkRange(b, 15192, 15871, 96);
+    checkRange(b, 15871, 15998, 95);
+    checkRange(b, 15998, 17017, 59);
+    checkRange(b, 17017, 17288, 76);
+    checkRange(b, 17288, 17312, 57);
+    checkRange(b, 17312, 17342, 59);
+    checkRange(b, 17342, 17464, 32);
+    checkRange(b, 17464, 17661, 89);
+    checkRange(b, 17661, 17727, 59);
+    checkRange(b, 17727, 17733, 5);
+    checkRange(b, 17733, 17893, 96);
+    checkRange(b, 17893, 18553, 77);
+    checkRange(b, 18553, 18744, 42);
+    checkRange(b, 18744, 18801, 76);
+    checkRange(b, 18801, 18825, 57);
+    checkRange(b, 18825, 18876, 59);
+    checkRange(b, 18876, 18885, 77);
+    checkRange(b, 18885, 18904, 41);
+    checkRange(b, 18904, 19567, 83);
+    checkRange(b, 19567, 20403, 96);
+    checkRange(b, 20403, 21274, 77);
+    checkRange(b, 21274, 21364, 100);
+    checkRange(b, 21364, 21468, 74);
+    checkRange(b, 21468, 21492, 93);
+    checkRange(b, 21492, 22051, 74);
+    checkRange(b, 22051, 22480, 68);
+    checkRange(b, 22480, 22685, 100);
+    checkRange(b, 22685, 22694, 68);
+    checkRange(b, 22694, 22821, 10);
+    checkRange(b, 22821, 22869, 100);
+    checkRange(b, 22869, 24107, 97);
+    checkRange(b, 24107, 24111, 37);
+    checkRange(b, 24111, 24236, 77);
+    checkRange(b, 24236, 24348, 72);
+    checkRange(b, 24348, 24515, 92);
+    checkRange(b, 24515, 24900, 83);
+    checkRange(b, 24900, 25136, 95);
+    checkRange(b, 25136, 25182, 85);
+    checkRange(b, 25182, 25426, 68);
+    checkRange(b, 25426, 25613, 89);
+    checkRange(b, 25613, 25830, 96);
+    checkRange(b, 25830, 26446, 100);
+    checkRange(b, 26446, 26517, 10);
+    checkRange(b, 26517, 27468, 92);
+    checkRange(b, 27468, 27503, 95);
+    checkRange(b, 27503, 27573, 77);
+    checkRange(b, 27573, 28245, 92);
+    checkRange(b, 28245, 28280, 95);
+    checkRange(b, 28280, 29502, 77);
+    checkRange(b, 29502, 29629, 42);
+    checkRange(b, 29629, 30387, 83);
+    checkRange(b, 30387, 30646, 77);
+    checkRange(b, 30646, 31066, 92);
+    checkRange(b, 31066, 31131, 77);
+    checkRange(b, 31131, 31322, 42);
+    checkRange(b, 31322, 31379, 76);
+    checkRange(b, 31379, 31403, 57);
+    checkRange(b, 31403, 31454, 59);
+    checkRange(b, 31454, 31463, 77);
+    checkRange(b, 31463, 31482, 41);
+    checkRange(b, 31482, 31649, 83);
+    checkRange(b, 31649, 31978, 72);
+    checkRange(b, 31978, 32145, 92);
+    checkRange(b, 32145, 32530, 83);
+    checkRange(b, 32530, 32766, 95);
+    checkRange(b, 32766, 32812, 85);
+    checkRange(b, 32812, 33056, 68);
+    checkRange(b, 33056, 33660, 89);
+    checkRange(b, 33660, 33752, 59);
+    checkRange(b, 33752, 33775, 36);
+    checkRange(b, 33775, 33778, 32);
+    checkRange(b, 33778, 34603, 9);
+    checkRange(b, 34603, 35218, 0);
+    checkRange(b, 35218, 35372, 10);
+    checkRange(b, 35372, 35486, 77);
+    checkRange(b, 35486, 35605, 5);
+    checkRange(b, 35605, 35629, 77);
+    checkRange(b, 35629, 35648, 41);
+    checkRange(b, 35648, 36547, 83);
+    checkRange(b, 36547, 36755, 74);
+    checkRange(b, 36755, 36767, 93);
+    checkRange(b, 36767, 36810, 83);
+    checkRange(b, 36810, 36839, 100);
+    checkRange(b, 36839, 37444, 96);
+    checkRange(b, 37444, 38060, 100);
+    checkRange(b, 38060, 38131, 10);
+    checkRange(b, 38131, 39082, 92);
+    checkRange(b, 39082, 39117, 95);
+    checkRange(b, 39117, 39187, 77);
+    checkRange(b, 39187, 39859, 92);
+    checkRange(b, 39859, 39894, 95);
+    checkRange(b, 39894, 40257, 77);
+    checkRange(b, 40257, 40344, 89);
+    checkRange(b, 40344, 40371, 59);
+    checkRange(b, 40371, 40804, 77);
+    checkRange(b, 40804, 40909, 5);
+    checkRange(b, 40909, 42259, 92);
+    checkRange(b, 42259, 42511, 77);
+    checkRange(b, 42511, 42945, 83);
+    checkRange(b, 42945, 43115, 77);
+    checkRange(b, 43115, 43306, 42);
+    checkRange(b, 43306, 43363, 76);
+    checkRange(b, 43363, 43387, 57);
+    checkRange(b, 43387, 43438, 59);
+    checkRange(b, 43438, 43447, 77);
+    checkRange(b, 43447, 43466, 41);
+    checkRange(b, 43466, 44129, 83);
+    checkRange(b, 44129, 44958, 96);
+    checkRange(b, 44958, 45570, 77);
+    checkRange(b, 45570, 45575, 92);
+    checkRange(b, 45575, 45640, 77);
+    checkRange(b, 45640, 45742, 42);
+    checkRange(b, 45742, 45832, 72);
+    checkRange(b, 45832, 45999, 92);
+    checkRange(b, 45999, 46384, 83);
+    checkRange(b, 46384, 46596, 95);
+    checkRange(b, 46596, 46654, 92);
+    checkRange(b, 46654, 47515, 83);
+    checkRange(b, 47515, 47620, 77);
+    checkRange(b, 47620, 47817, 79);
+    checkRange(b, 47817, 47951, 95);
+    checkRange(b, 47951, 48632, 100);
+    checkRange(b, 48632, 48699, 97);
+    checkRange(b, 48699, 48703, 37);
+    checkRange(b, 48703, 49764, 77);
+    checkRange(b, 49764, 49955, 42);
+    checkRange(b, 49955, 50012, 76);
+    checkRange(b, 50012, 50036, 57);
+    checkRange(b, 50036, 50087, 59);
+    checkRange(b, 50087, 50096, 77);
+    checkRange(b, 50096, 50115, 41);
+    checkRange(b, 50115, 50370, 83);
+    checkRange(b, 50370, 51358, 92);
+    checkRange(b, 51358, 51610, 77);
+    checkRange(b, 51610, 51776, 83);
+    checkRange(b, 51776, 51833, 89);
+    checkRange(b, 51833, 52895, 100);
+    checkRange(b, 52895, 53029, 97);
+    checkRange(b, 53029, 53244, 68);
+    checkRange(b, 53244, 54066, 100);
+    checkRange(b, 54066, 54133, 97);
+    checkRange(b, 54133, 54137, 37);
+    checkRange(b, 54137, 55198, 77);
+    checkRange(b, 55198, 55389, 42);
+    checkRange(b, 55389, 55446, 76);
+    checkRange(b, 55446, 55470, 57);
+    checkRange(b, 55470, 55521, 59);
+    checkRange(b, 55521, 55530, 77);
+    checkRange(b, 55530, 55549, 41);
+    checkRange(b, 55549, 56212, 83);
+    checkRange(b, 56212, 57048, 96);
+    checkRange(b, 57048, 58183, 77);
+    checkRange(b, 58183, 58202, 41);
+    checkRange(b, 58202, 58516, 83);
+    checkRange(b, 58516, 58835, 95);
+    checkRange(b, 58835, 58855, 77);
+    checkRange(b, 58855, 59089, 95);
+    checkRange(b, 59089, 59145, 77);
+    checkRange(b, 59145, 59677, 99);
+    checkRange(b, 59677, 60134, 0);
+    checkRange(b, 60134, 60502, 89);
+    checkRange(b, 60502, 60594, 59);
+    checkRange(b, 60594, 60617, 36);
+    checkRange(b, 60617, 60618, 32);
+    checkRange(b, 60618, 60777, 42);
+    checkRange(b, 60777, 60834, 76);
+    checkRange(b, 60834, 60858, 57);
+    checkRange(b, 60858, 60909, 59);
+    checkRange(b, 60909, 60918, 77);
+    checkRange(b, 60918, 60937, 41);
+    checkRange(b, 60937, 61600, 83);
+    checkRange(b, 61600, 62436, 96);
+    checkRange(b, 62436, 63307, 77);
+    checkRange(b, 63307, 63397, 100);
+    checkRange(b, 63397, 63501, 74);
+    checkRange(b, 63501, 63525, 93);
+    checkRange(b, 63525, 63605, 74);
+    checkRange(b, 63605, 63704, 100);
+    checkRange(b, 63704, 63771, 97);
+    checkRange(b, 63771, 63775, 37);
+    checkRange(b, 63775, 64311, 77);
+    checkRange(b, 64311, 64331, 26);
+    checkRange(b, 64331, 64518, 92);
+    checkRange(b, 64518, 64827, 11);
+    checkRange(b, 64827, 64834, 26);
+    checkRange(b, 64834, 65536, 0);
+}
+
+// Make sure dead code doesn't prevent compilation.
+wasmEvalText(
+    `(module
+       (memory 0 10)
+       (data (i32.const 0))
+       (func
+         (return)
+         (memory.init 0)
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (memory 0 10)
+       (func
+         (return)
+         (memory.fill)
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (table (export "t") 10 funcref)
+       (elem (i32.const 0) 0)
+       (func
+         (return)
+         (elem.drop 0)
+        )
+    )`);
diff --git a/js/src/jit-test/tests/wasm/passive-segs-partial-mem.js b/js/src/jit-test/tests/wasm/passive-segs-partial-mem.js
new file mode 100644
index 0000000000..5e9351ef8a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/passive-segs-partial-mem.js
@@ -0,0 +1,174 @@
+let conf = getBuildConfiguration();
+if (conf.debug &&
+    (conf["arm-simulator"] || conf["arm64-simulator"] ||
+     conf["mips32-simulator"] || conf["mips64-simulator"]))
+{
+    // Will timeout, so just quit early.
+    quit(0);
+}
+
+// Sundry test cases for the "partial write" bounds checking semantics.
+
+const PAGESIZE = 65536;
+
+// memory.fill: out of bounds, should not perform writes
+//
+// Arithmetic overflow of memory offset + len should not affect the behavior, we
+// should still fill up to the limit.
+
+function mem_fill(min, max, shared, backup, write=backup*2) {
+    if (shared == "shared" && !sharedMemoryEnabled())
+        return;
+    let ins = wasmEvalText(
+        `(module
+           (memory (export "mem") ${min} ${max} ${shared})
+           (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+             (memory.fill (local.get $offs) (local.get $val) (local.get $len))))`);
+    // A fill past the end should throw *and* not have filled all the way up to
+    // the end
+    let offs = min*PAGESIZE - backup;
+    let val = 37;
+    assertErrorMessage(() => ins.exports.run(offs, val, write),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    let v = new Uint8Array(ins.exports.mem.buffer);
+    for (let i=0; i < backup; i++)
+        assertEq(v[offs+i], 0);
+    for (let i=0; i < offs; i++)
+        assertEq(v[i], 0);
+}
+
+mem_fill(1, 1, "", 256);
+mem_fill(1, 1, "", 257);
+mem_fill(1, 1, "", 257, 0xFFFFFFFF); // offs + len overflows 32-bit
+
+mem_fill(2, 4, "shared", 256);
+mem_fill(2, 4, "shared", 257);
+mem_fill(2, 4, "shared", 257, 0xFFFFFFFF); // offs + len overflows 32-bit
+
+// memory.init: out of bounds of the memory or the segment, and should not perform
+// the operation at all.
+//
+// Arithmetic overflow of memoffset + len or of bufferoffset + len should not
+// affect the behavior.
+
+// Note, the length of the data segment is 16.
+const mem_init_len = 16;
+
+function mem_init(min, max, shared, backup, write) {
+    if (shared == "shared" && !sharedMemoryEnabled())
+        return;
+    let ins = wasmEvalText(
+        `(module
+           (memory (export "mem") ${min} ${max} ${shared})
+           (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+           (func (export "run") (param $offs i32) (param $len i32)
+             (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))`);
+    // A fill writing past the end of the memory should throw *and* not have filled
+    // all the way up to the end.
+    //
+    // A fill reading past the end of the segment should throw *and* not have filled
+    // memory with as much data as was available.
+    let offs = min*PAGESIZE - backup;
+    assertErrorMessage(() => ins.exports.run(offs, write),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    let v = new Uint8Array(ins.exports.mem.buffer);
+    for (let i=0; i < min; i++)
+        assertEq(v[offs + i], 0);
+}
+
+// We exceed the bounds of the memory but not of the data segment
+mem_init(1, 1, "", Math.floor(mem_init_len/2), mem_init_len);
+mem_init(1, 1, "", Math.floor(mem_init_len/2)+1, mem_init_len);
+mem_init(2, 4, "shared", Math.floor(mem_init_len/2), mem_init_len);
+mem_init(2, 4, "shared", Math.floor(mem_init_len/2)+1, mem_init_len);
+
+// We exceed the bounds of the data segment but not the memory
+mem_init(1, 1, "", mem_init_len*4, mem_init_len*2-2);
+mem_init(1, 1, "", mem_init_len*4-1, mem_init_len*2-1);
+mem_init(2, 4, "shared", mem_init_len*4, mem_init_len*2-2);
+mem_init(2, 4, "shared", mem_init_len*4-1, mem_init_len*2-1);
+
+// We arithmetically overflow the memory limit but not the segment limit
+mem_init(1, "", "", Math.floor(mem_init_len/2), 0xFFFFFF00);
+
+// We arithmetically overflow the segment limit but not the memory limit
+mem_init(1, "", "", PAGESIZE, 0xFFFFFFFC);
+
+// memory.copy: out of bounds of the memory for the source or target, and should
+// not perform at all.  Major cases:
+//
+// - non-overlapping regions
+// - overlapping regions with src >= dest
+// - overlapping regions with src == dest
+// - overlapping regions with src < dest
+// - arithmetic overflow on src addresses
+// - arithmetic overflow on target addresses
+//
+// for each of those,
+//
+// - src address oob
+// - target address oob
+// - both oob
+
+function mem_copy(min, max, shared, srcOffs, targetOffs, len) {
+    if (shared == "shared" && !sharedMemoryEnabled())
+        return;
+    let ins = wasmEvalText(
+        `(module
+           (memory (export "mem") ${min} ${max} ${shared})
+           (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+             (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))`);
+
+    let v = new Uint8Array(ins.exports.mem.buffer);
+
+    let copyDown = srcOffs < targetOffs;
+    let targetAvail = v.length - targetOffs;
+    let srcAvail = v.length - srcOffs;
+    let srcLim = srcOffs + Math.min(len, targetAvail, srcAvail);
+
+    for (let i=srcOffs, j=0; i < srcLim; i++, j++)
+        v[i] = j;
+    assertErrorMessage(() => ins.exports.run(targetOffs, srcOffs, len),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    for (var i=0, s=0; i < v.length; i++ ) {
+        if (i >= srcOffs && i < srcLim) {
+            assertEq(v[i], (s++) & 0xFF);
+            continue;
+        }
+        assertEq(v[i], 0);
+    }
+}
+
+// OOB target address, nonoverlapping
+mem_copy(1, 1, "", 0, PAGESIZE-20, 40);
+mem_copy(1, 1, "", 0, PAGESIZE-21, 39);
+mem_copy(2, 4, "shared", 0, 2*PAGESIZE-20, 40);
+mem_copy(2, 4, "shared", 0, 2*PAGESIZE-21, 39);
+
+// OOB source address, nonoverlapping
+mem_copy(1, 1, "", PAGESIZE-20, 0, 40);
+mem_copy(1, 1, "", PAGESIZE-21, 0, 39);
+mem_copy(2, 4, "shared", 2*PAGESIZE-20, 0, 40);
+mem_copy(2, 4, "shared", 2*PAGESIZE-21, 0, 39);
+
+// OOB target address, overlapping, src < target
+mem_copy(1, 1, "", PAGESIZE-50, PAGESIZE-20, 40);
+
+// OOB source address, overlapping, target < src
+mem_copy(1, 1, "", PAGESIZE-20, PAGESIZE-50, 40);
+
+// OOB both, overlapping, including target == src
+mem_copy(1, 1, "", PAGESIZE-30, PAGESIZE-20, 40);
+mem_copy(1, 1, "", PAGESIZE-20, PAGESIZE-30, 40);
+mem_copy(1, 1, "", PAGESIZE-20, PAGESIZE-20, 40);
+
+// Arithmetic overflow on source address.
+mem_copy(1, "", "", PAGESIZE-20, 0, 0xFFFFF000);
+
+// Arithmetic overflow on target adddress is an overlapping case.
+mem_copy(1, 1, "", PAGESIZE-0x1000, PAGESIZE-20, 0xFFFFFF00);
+
diff --git a/js/src/jit-test/tests/wasm/passive-segs-partial-table.js b/js/src/jit-test/tests/wasm/passive-segs-partial-table.js
new file mode 100644
index 0000000000..2d2e8fcf72
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/passive-segs-partial-table.js
@@ -0,0 +1,153 @@
+// Sundry test cases for the "partial write" bounds checking semantics.
+
+// table.init: out of bounds of the table or the element segment, and should
+// not perform the operation at all.
+//
+// Arithmetic overflow of tableoffset + len or of segmentoffset + len should not
+// affect the behavior.
+
+// Note, the length of the element segment is 16.
+const tbl_init_len = 16;
+
+function tbl_init(min, max, backup, write, segoffs=0) {
+    let ins = wasmEvalText(
+        `(module
+           (table (export "tbl") ${min} ${max} funcref)
+           (elem func $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+           (func $f0 (export "f0"))
+           (func $f1 (export "f1"))
+           (func $f2 (export "f2"))
+           (func $f3 (export "f3"))
+           (func $f4 (export "f4"))
+           (func $f5 (export "f5"))
+           (func $f6 (export "f6"))
+           (func $f7 (export "f7"))
+           (func $f8 (export "f8"))
+           (func $f9 (export "f9"))
+           (func $f10 (export "f10"))
+           (func $f11 (export "f11"))
+           (func $f12 (export "f12"))
+           (func $f13 (export "f13"))
+           (func $f14 (export "f14"))
+           (func $f15 (export "f15"))
+           (func (export "run") (param $offs i32) (param $len i32)
+             (table.init 0 (local.get $offs) (i32.const ${segoffs}) (local.get $len))))`);
+    // A fill writing past the end of the table should throw *and* have filled
+    // all the way up to the end.
+    //
+    // 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;
+    assertErrorMessage(() => ins.exports.run(offs, write),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+    let tbl = ins.exports.tbl;
+    for (let i=0; i < min; i++) {
+        assertEq(tbl.get(i), null);
+    }
+}
+
+// We exceed the bounds of the table but not of the element segment
+tbl_init(tbl_init_len*2, tbl_init_len*4, Math.floor(tbl_init_len/2), tbl_init_len);
+tbl_init(tbl_init_len*2, tbl_init_len*4, Math.floor(tbl_init_len/2)-1, tbl_init_len);
+
+// We exceed the bounds of the element segment but not the table
+tbl_init(tbl_init_len*10, tbl_init_len*20, tbl_init_len*4, tbl_init_len*2);
+tbl_init(tbl_init_len*10, tbl_init_len*20, tbl_init_len*4-1, tbl_init_len*2-1);
+
+// We arithmetically overflow the table limit but not the segment limit
+tbl_init(tbl_init_len*4, tbl_init_len*4, tbl_init_len, 0xFFFFFFF0);
+
+// We arithmetically overflow the segment limit but not the table limit
+tbl_init(tbl_init_len, tbl_init_len, tbl_init_len, 0xFFFFFFFC, Math.floor(tbl_init_len/2));
+
+// table.copy: out of bounds of the table for the source or target, and should
+// perform the operation at all.  Major cases:
+//
+// - non-overlapping regions
+// - overlapping regions with src > dest
+// - overlapping regions with src == dest
+// - overlapping regions with src < dest
+// - arithmetic overflow on src addresses
+// - arithmetic overflow on target addresses
+//
+// for each of those,
+//
+// - src address oob
+// - target address oob
+// - both oob
+//
+// Note we do not test the multi-table case here because that is part of the
+// reftypes proposal; tests are in the gc/ subdirectory.
+
+const tbl_copy_len = 16;
+
+function tbl_copy(min, max, srcOffs, targetOffs, len) {
+    let ins = wasmEvalText(
+        `(module
+           (table (export "tbl") ${min} ${max} funcref)
+           (func $f0 (export "f0"))
+           (func $f1 (export "f1"))
+           (func $f2 (export "f2"))
+           (func $f3 (export "f3"))
+           (func $f4 (export "f4"))
+           (func $f5 (export "f5"))
+           (func $f6 (export "f6"))
+           (func $f7 (export "f7"))
+           (func $f8 (export "f8"))
+           (func $f9 (export "f9"))
+           (func $f10 (export "f10"))
+           (func $f11 (export "f11"))
+           (func $f12 (export "f12"))
+           (func $f13 (export "f13"))
+           (func $f14 (export "f14"))
+           (func $f15 (export "f15"))
+           (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+             (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))`);
+
+    let tbl = ins.exports.tbl;
+
+    let copyDown = srcOffs < targetOffs;
+    let targetAvail = tbl.length - targetOffs;
+    let srcAvail = tbl.length - srcOffs;
+    let srcLim = srcOffs + Math.min(len, targetAvail, srcAvail);
+
+    for (let i=srcOffs, j=0; i < srcLim; i++, j++)
+        tbl.set(i, ins.exports["f" + j]);
+    assertErrorMessage(() => ins.exports.run(targetOffs, srcOffs, len),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+
+    for (var i=0, s=0; i < tbl.length; i++ ) {
+        if (i >= srcOffs && i < srcLim) {
+            assertEq(tbl.get(i), ins.exports["f" + (s++)]);
+            continue;
+        }
+        assertEq(tbl.get(i), null);
+    }
+}
+
+// OOB target address, nonoverlapping
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, 0, Math.floor(1.5*tbl_copy_len), tbl_copy_len);
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, 0, Math.floor(1.5*tbl_copy_len)-1, tbl_copy_len-1);
+
+// OOB source address, nonoverlapping
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, Math.floor(1.5*tbl_copy_len), 0, tbl_copy_len);
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, Math.floor(1.5*tbl_copy_len)-1, 0, tbl_copy_len-1);
+
+// OOB target address, overlapping, src < target
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, tbl_copy_len-5, Math.floor(1.5*tbl_copy_len), tbl_copy_len);
+
+// OOB source address, overlapping, target < src
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, Math.floor(1.5*tbl_copy_len), tbl_copy_len-5, tbl_copy_len);
+
+// OOB both, overlapping, including src == target
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, tbl_copy_len+5, Math.floor(1.5*tbl_copy_len), tbl_copy_len);
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, Math.floor(1.5*tbl_copy_len), tbl_copy_len+5, tbl_copy_len);
+tbl_copy(tbl_copy_len*2, tbl_copy_len*4, tbl_copy_len+5, tbl_copy_len+5, tbl_copy_len);
+
+// Arithmetic overflow on source address.
+tbl_copy(tbl_copy_len*8, tbl_copy_len*8, tbl_copy_len*7, 0, 0xFFFFFFE0);
+
+// Arithmetic overflow on target adddress is an overlapping case.
+tbl_copy(tbl_copy_len*8, tbl_copy_len*8, 0, tbl_copy_len*7, 0xFFFFFFE0);
diff --git a/js/src/jit-test/tests/wasm/profiling.js b/js/src/jit-test/tests/wasm/profiling.js
new file mode 100644
index 0000000000..06d1fb676c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/profiling.js
@@ -0,0 +1,416 @@
+// |jit-test| skip-if: !WasmHelpers.isSingleStepPropfilingEnabled
+
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const Table = WebAssembly.Table;
+
+const {
+    assertEqImpreciseStacks,
+    assertEqPreciseStacks,
+    startProfiling,
+    endProfiling
+} = WasmHelpers;
+
+function test(code, importObj, expectedStacks)
+{
+    enableGeckoProfiling();
+
+    var f = wasmEvalText(code, importObj).exports[""];
+    startProfiling();
+    f();
+    assertEqImpreciseStacks(endProfiling(), expectedStacks);
+
+    disableGeckoProfiling();
+}
+
+test(
+`(module
+    (func (result i32) (i32.const 42))
+    (export "" (func 0))
+)`,
+{},
+["", ">", "0,>", ">", ""]);
+
+test(
+`(module
+    (func (result i32) (i32.add (call 1) (i32.const 1)))
+    (func (result i32) (i32.const 42))
+    (export "" (func 0))
+)`,
+{},
+["", ">", "0,>", "1,0,>", "0,>", ">", ""]);
+
+test(
+`(module
+    (func $foo (call_indirect (type 0) (i32.const 0)))
+    (func $bar)
+    (table funcref (elem $bar))
+    (export "" (func $foo))
+)`,
+{},
+["", ">", "0,>", "1,0,>", "0,>", ">", ""]);
+
+test(
+`(module
+    (import $foo "" "foo")
+    (table funcref (elem $foo))
+    (func $bar (call_indirect (type 0) (i32.const 0)))
+    (export "" (func $bar))
+)`,
+{"":{foo:()=>{}}},
+["", ">", "1,>", "0,1,>", "<,0,1,>", "0,1,>", "1,>", ">", ""]);
+
+test(`(module
+    (import $f32 "Math" "sin" (param f32) (result f32))
+    (func (export "") (param f32) (result f32)
+        local.get 0
+        call $f32
+    )
+)`,
+this,
+["", ">", "1,>", "<,1,>", "1,>", ">", ""]);
+
+if (getBuildConfiguration()["arm-simulator"]) {
+    // On ARM, some int64 operations are calls to C++.
+    for (let op of ['div_s', 'rem_s', 'div_u', 'rem_u']) {
+        test(`(module
+            (func (export "") (param i32) (result i32)
+                local.get 0
+                i64.extend_s/i32
+                i64.const 0x1a2b3c4d5e6f
+                i64.${op}
+                i32.wrap/i64
+            )
+        )`,
+        this,
+        ["", ">", "0,>", "<,0,>", `i64.${op},0,>`, "<,0,>", "0,>", ">", ""],
+        );
+    }
+}
+
+// memory.size is a callout.
+test(`(module
+    (memory 1)
+    (func (export "") (result i32)
+         memory.size
+    )
+)`,
+this,
+["", ">", "0,>", "<,0,>", "memory.size,0,>", "<,0,>", "0,>", ">", ""],
+);
+
+// memory.grow is a callout.
+test(`(module
+    (memory 1)
+    (func (export "") (result i32)
+         i32.const 1
+         memory.grow
+    )
+)`,
+this,
+["", ">", "0,>", "<,0,>", "memory.grow,0,>", "<,0,>", "0,>", ">", ""],
+);
+
+// A few math builtins.
+for (let type of ['f32', 'f64']) {
+    for (let func of ['ceil', 'floor', 'nearest', 'trunc']) {
+        test(`(module
+            (func (export "") (param ${type}) (result ${type})
+                local.get 0
+                ${type}.${func}
+            )
+        )`,
+        this,
+        ["", ">", "0,>", "<,0,>", `${type}.${func},0,>`, "<,0,>", "0,>", ">", ""]);
+    }
+}
+
+(function() {
+    // Error handling.
+    function testError(code, error, expect)
+    {
+        enableGeckoProfiling();
+        var f = wasmEvalText(code).exports[""];
+        enableSingleStepProfiling();
+        assertThrowsInstanceOf(f, error);
+        assertEqImpreciseStacks(disableSingleStepProfiling(), expect);
+        disableGeckoProfiling();
+    }
+
+    testError(
+    `(module
+        (func $foo (unreachable))
+        (func (export "") (call $foo))
+    )`,
+    WebAssembly.RuntimeError,
+    ["", ">", "1,>", "0,1,>", "1,>", "", ">", ""]);
+
+    testError(
+    `(module
+        (type $good (func))
+        (type $bad (func (param i32)))
+        (func $foo (call_indirect (type $bad) (i32.const 1) (i32.const 0)))
+        (func $bar (type $good))
+        (table funcref (elem $bar))
+        (export "" (func $foo))
+    )`,
+    WebAssembly.RuntimeError,
+    ["", ">", "0,>", "1,0,>", ">", "", ">", ""]);
+})();
+
+(function() {
+    // Tables fun.
+    var e = wasmEvalText(`
+    (module
+        (func $foo (result i32) (i32.const 42))
+        (export "foo" (func $foo))
+        (func $bar (result i32) (i32.const 13))
+        (table 10 funcref)
+        (elem (i32.const 0) $foo $bar)
+        (export "tbl" (table 0))
+    )`).exports;
+    assertEq(e.foo(), 42);
+    assertEq(e.tbl.get(0)(), 42);
+    assertEq(e.tbl.get(1)(), 13);
+
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e.tbl.get(0)(), 42);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "0,>", ">", ""]);
+    disableGeckoProfiling();
+
+    assertEq(e.foo(), 42);
+    assertEq(e.tbl.get(0)(), 42);
+    assertEq(e.tbl.get(1)(), 13);
+
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e.tbl.get(1)(), 13);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "1,>", ">", ""]);
+    disableGeckoProfiling();
+
+    assertEq(e.tbl.get(0)(), 42);
+    assertEq(e.tbl.get(1)(), 13);
+    assertEq(e.foo(), 42);
+
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e.foo(), 42);
+    assertEq(e.tbl.get(1)(), 13);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "0,>", ">", "", ">", "1,>", ">", ""]);
+    disableGeckoProfiling();
+
+    var e2 = wasmEvalText(`
+    (module
+        (type $v2i (func (result i32)))
+        (import "a" "b" (table 10 funcref))
+        (elem (i32.const 2) $bar)
+        (func $bar (result i32) (i32.const 99))
+        (func $baz (param $i i32) (result i32) (call_indirect (type $v2i) (local.get $i)))
+        (export "baz" (func $baz))
+    )`, {a:{b:e.tbl}}).exports;
+
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e2.baz(0), 42);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "1,>", "0,1,>", "1,>", ">", ""]);
+    disableGeckoProfiling();
+
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e2.baz(1), 13);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "1,>", "1,1,>", "1,>", ">", ""]);
+    disableGeckoProfiling();
+
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e2.baz(2), 99);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "1,>", "0,1,>", "1,>", ">", ""]);
+    disableGeckoProfiling();
+})();
+
+(function() {
+    // Optimized wasm->wasm import.
+    var m1 = new Module(wasmTextToBinary(`(module
+        (func $foo (result i32) (i32.const 42))
+        (export "foo" (func $foo))
+    )`));
+    var m2 = new Module(wasmTextToBinary(`(module
+        (import $foo "a" "foo" (result i32))
+        (func $bar (result i32) (call $foo))
+        (export "bar" (func $bar))
+    )`));
+
+    // Instantiate while not active:
+    var e1 = new Instance(m1).exports;
+    var e2 = new Instance(m2, {a:e1}).exports;
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+    assertEq(e2.bar(), 42);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "1,>", "0,1,>", "1,>", ">", ""]);
+    disableGeckoProfiling();
+    assertEq(e2.bar(), 42);
+
+    // Instantiate while active:
+    enableGeckoProfiling();
+    var e3 = new Instance(m1).exports;
+    var e4 = new Instance(m2, {a:e3}).exports;
+    enableSingleStepProfiling();
+    assertEq(e4.bar(), 42);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "1,>", "0,1,>", "1,>", ">", ""]);
+    disableGeckoProfiling();
+    assertEq(e4.bar(), 42);
+})();
+
+(function() {
+    // FFIs test.
+    let prevOptions = getJitCompilerOptions();
+
+    // Skip tests if baseline isn't enabled, since the stacks might differ by
+    // a few instructions.
+    if (prevOptions['baseline.enable'] === 0)
+        return;
+
+    setJitCompilerOption("baseline.warmup.trigger", 10);
+
+    enableGeckoProfiling();
+
+    var m = new Module(wasmTextToBinary(`(module
+        (import $ffi "a" "ffi" (param i32) (result i32))
+
+        (import $missingOneArg "a" "sumTwo" (param i32) (result i32))
+
+        (func (export "foo") (param i32) (result i32)
+         local.get 0
+         call $ffi)
+
+        (func (export "id") (param i32) (result i32)
+         local.get 0
+         call $missingOneArg
+        )
+    )`));
+
+    var valueToConvert = 0;
+    function ffi(n) {
+        new Error().stack; // enter VM to clobber FP register.
+        if (n == 1337) { return valueToConvert };
+        return 42;
+    }
+
+    function sumTwo(a, b) {
+        return (a|0)+(b|0)|0;
+    }
+
+    // Baseline compile ffi.
+    for (var i = 20; i --> 0;) {
+        ffi(i);
+        sumTwo(i-1, i+1);
+    }
+
+    var imports = {
+        a: {
+            ffi,
+            sumTwo
+        }
+    };
+
+    var i = new Instance(m, imports).exports;
+
+    // Enable the jit exit.
+    assertEq(i.foo(0), 42);
+    assertEq(i.id(13), 13);
+
+    // Test normal conditions.
+    enableSingleStepProfiling();
+    assertEq(i.foo(0), 42);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "2,>", "<,2,>",
+        // Losing stack information while the JIT func prologue sets profiler
+        // virtual FP.
+        "",
+        // Callee time.
+        "<,2,>",
+        // Losing stack information while we're exiting JIT func epilogue and
+        // recovering wasm FP.
+        "",
+        // Back into the jit exit (frame info has been recovered).
+        "<,2,>",
+        // Normal unwinding.
+        "2,>", ">", ""]);
+
+    // Test rectifier frame.
+    enableSingleStepProfiling();
+    assertEq(i.id(100), 100);
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "3,>", "<,3,>",
+        // Rectifier frame time is spent here (lastProfilingFrame has not been
+        // set).
+        "",
+        "<,3,>",
+        // Rectifier frame unwinding time is spent here.
+        "",
+        "<,3,>",
+        "3,>", ">", ""]);
+
+    // Test OOL coercion path.
+    valueToConvert = 2**31;
+
+    enableSingleStepProfiling();
+    assertEq(i.foo(1337), -(2**31));
+    assertEqImpreciseStacks(disableSingleStepProfiling(), ["", ">", "2,>", "<,2,>", "", "<,2,>", "",
+        // Back into the jit exit (frame info has been recovered).
+        // Inline conversion fails, we skip to the OOL path, call from there
+        // and get back to the jit exit.
+        "<,2,>",
+        // Normal unwinding.
+        "2,>", ">", ""]);
+
+    disableGeckoProfiling();
+    setJitCompilerOption("baseline.warmup.trigger", prevOptions["baseline.warmup.trigger"]);
+})();
+
+// Make sure it's possible to single-step through call through debug-enabled code.
+(function() {
+ enableGeckoProfiling();
+
+ let g = newGlobal('');
+ let dbg = new Debugger(g);
+ dbg.onEnterFrame = () => {};
+ enableSingleStepProfiling();
+ g.eval(`
+    var code = wasmTextToBinary('(module (func (export "run") (result i32) i32.const 42))');
+    var i = new WebAssembly.Instance(new WebAssembly.Module(code));
+    assertEq(i.exports.run(), 42);
+ `);
+
+ disableSingleStepProfiling();
+ disableGeckoProfiling();
+})();
+
+// Ion->wasm calls.
+let func = wasmEvalText(`(module
+    (func $inner (result i32) (param i32) (param i32)
+        local.get 0
+        local.get 1
+        i32.add
+    )
+    (func (export "add") (result i32) (param i32) (param i32)
+     local.get 0
+     local.get 1
+     call $inner
+    )
+)`).exports.add;
+
+(function() {
+    enableGeckoProfiling();
+    // 10 is enough in ion eager mode.
+    for (let i = 0; i < 10; i++) {
+        enableSingleStepProfiling();
+        let res = func(i - 1, i + 1);
+        assertEqPreciseStacks(disableSingleStepProfiling(), [
+            ['', '>', '1,>', '0,1,>' , '1,>', '>', ''],      // slow entry
+            ['', '!>', '1,!>', '0,1,!>' , '1,!>', '!>', ''], // fast entry
+            ['', '1', '0,1' , '1', ''],                      // inlined jit call
+        ]);
+        assertEq(res, i+i);
+    }
+    disableGeckoProfiling();
+})();
diff --git a/js/src/jit-test/tests/wasm/prototypes.js b/js/src/jit-test/tests/wasm/prototypes.js
new file mode 100644
index 0000000000..2c57009b2c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/prototypes.js
@@ -0,0 +1,27 @@
+class _Module extends WebAssembly.Module {}
+class _Instance extends WebAssembly.Instance {}
+class _Memory extends WebAssembly.Memory {}
+class _Table extends WebAssembly.Table {}
+class _Global extends WebAssembly.Global {}
+
+let binary = wasmTextToBinary('(module)');
+
+let module = new _Module(binary);
+assertEq(module instanceof _Module, true);
+assertEq(module instanceof WebAssembly.Module, true);
+
+let instance = new _Instance(module);
+assertEq(instance instanceof _Instance, true);
+assertEq(instance instanceof WebAssembly.Instance, true);
+
+let memory = new _Memory({initial: 0, maximum: 1});
+assertEq(memory instanceof _Memory, true);
+assertEq(memory instanceof WebAssembly.Memory, true);
+
+let table = new _Table({initial: 0, element: 'anyfunc'});
+assertEq(table instanceof _Table, true);
+assertEq(table instanceof WebAssembly.Table, true);
+
+let global = new _Global({value: 'i32', mutable: false}, 0);
+assertEq(global instanceof _Global, true);
+assertEq(global instanceof WebAssembly.Global, true);
diff --git a/js/src/jit-test/tests/wasm/ref-types/directives.txt b/js/src/jit-test/tests/wasm/ref-types/directives.txt
new file mode 100644
index 0000000000..ed90b6bd5f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); test-also=--wasm-test-serialization; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref-boxing.js b/js/src/jit-test/tests/wasm/ref-types/externref-boxing.js
new file mode 100644
index 0000000000..854f3e7815
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref-boxing.js
@@ -0,0 +1,140 @@
+// Moving a JS value through a wasm externref is a pair of boxing/unboxing
+// conversions that leaves the value unchanged.  There are many cases,
+// along these axes:
+//
+//  - global variables
+//  - tables
+//  - function parameters and returns
+//  - struct fields [for the gc feature], see externref-boxing-struct.js
+
+// Global variables can receive values via several mechanisms:
+//
+// - on initialization when created from JS
+// - on initialization when created in Wasm, from an imported global
+// - through the "value" property if the value is mutable
+// - through the global.set wasm instruction, ditto
+//
+// Their values can be obtained in several ways:
+//
+// - through the "value" property
+// - through the global.get wasm instruction
+// - read when other globals are initialized from them
+
+// Set via initialization and read via 'value'
+
+for (let v of WasmExternrefValues)
+{
+    let g = new WebAssembly.Global({value: "externref"}, v);
+    assertEq(g.value, v);
+}
+
+// Set via 'value' and read via 'value'
+
+for (let v of WasmExternrefValues)
+{
+    let g = new WebAssembly.Global({value: "externref", mutable: true});
+    g.value = v;
+    assertEq(g.value, v);
+}
+
+// Set via initialization, then read via global.get and returned
+
+for (let v of WasmExternrefValues)
+{
+    let g = new WebAssembly.Global({value: "externref"}, v);
+    let ins = wasmEvalText(
+        `(module
+           (import "m" "g" (global $glob externref))
+           (func (export "f") (result externref)
+             (global.get $glob)))`,
+        {m:{g}});
+    assertEq(ins.exports.f(), v);
+}
+
+// Set via global.set, then read via 'value'
+
+for (let v of WasmExternrefValues)
+{
+    let g = new WebAssembly.Global({value: "externref", mutable: true});
+    let ins = wasmEvalText(
+        `(module
+           (import "m" "g" (global $glob (mut externref)))
+           (func (export "f") (param $v externref)
+             (global.set $glob (local.get $v))))`,
+        {m:{g}});
+    ins.exports.f(v);
+    assertEq(g.value, v);
+}
+
+// Tables of externref can receive values via several mechanisms:
+//
+// - through WebAssembly.Table.prototype.set()
+// - through the table.set, table.copy, and table.grow instructions
+// - through table.fill
+// - through WebAssembly.Table.prototype.grow()
+//
+// Their values can be read in several ways:
+//
+// - through WebAssembly.Table.prototype.get()
+// - through the table.get and table.copy instructions
+//
+// (Note, tables are always initialized to null when created from JS)
+
+// .set() and .get()
+
+for (let v of WasmExternrefValues)
+{
+    let t = new WebAssembly.Table({element: "externref", initial: 10});
+    t.set(3, v);
+    assertEq(t.get(3), v);
+}
+
+// write with table.set, read with .get()
+
+for (let v of WasmExternrefValues)
+{
+    let t = new WebAssembly.Table({element: "externref", initial: 10});
+    let ins = wasmEvalText(
+        `(module
+           (import "m" "t" (table $t 10 externref))
+           (func (export "f") (param $v externref)
+             (table.set $t (i32.const 3) (local.get $v))))`,
+        {m:{t}});
+    ins.exports.f(v);
+    assertEq(t.get(3), v);
+}
+
+// write with .set(), read with table.get
+
+for (let v of WasmExternrefValues)
+{
+    let t = new WebAssembly.Table({element: "externref", initial: 10});
+    let ins = wasmEvalText(
+        `(module
+           (import "m" "t" (table $t 10 externref))
+           (func (export "f") (result externref)
+             (table.get $t (i32.const 3))))`,
+        {m:{t}});
+    t.set(3, v);
+    assertEq(ins.exports.f(), v);
+}
+
+// Imported JS functions can receive externref values as parameters and return
+// them.
+
+for (let v of WasmExternrefValues)
+{
+    let returner = function () { return v; };
+    let receiver = function (w) { assertEq(w, v); };
+    let ins = wasmEvalText(
+        `(module
+           (import "m" "returner" (func $returner (result externref)))
+           (import "m" "receiver" (func $receiver (param externref)))
+           (func (export "test_returner") (result externref)
+             (call $returner))
+           (func (export "test_receiver") (param $v externref)
+             (call $receiver (local.get $v))))`,
+        {m:{returner, receiver}});
+    assertEq(ins.exports.test_returner(), v);
+    ins.exports.test_receiver(v);
+}
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref-fastpaths.js b/js/src/jit-test/tests/wasm/ref-types/externref-fastpaths.js
new file mode 100644
index 0000000000..749a7c788b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref-fastpaths.js
@@ -0,0 +1,100 @@
+setJitCompilerOption("baseline.warmup.trigger", 5);
+setJitCompilerOption("ion.warmup.trigger", 10);
+
+var iter = 1000;
+let objs = WasmExternrefValues;
+var index = 0;
+
+// Tests that:
+//
+//  * wasm->js calls along the fast path unbox externref correctly on entry to JS.
+//    This is tested by JS observing that the value that it receives is the same
+//    that was passed into wasm in the first place.
+//
+//  * js->wasm calls along the fast path box JS values into externref correctly on
+//    entry into wasm.  This is tested by the precise same test as the case
+//    above.
+//
+//  * js->wasm calls along the fast path unbox externref correctly on return from
+//    wasm.  This is tested by returning the passed-in value and observing in
+//    JS that the value is the same as the value that was passed in.
+
+// `p` will be a register argument on most platforms.
+
+function js_externref_regarg(p) {
+    if (p !== objs[index])
+        throw new Error("Bad argument at " + index);
+}
+
+// `p` will be a stack argument on all platforms.  In the internal ABI, the
+// externref parameter ends up in a stack slot in the call to js_externref_stackarg,
+// thus we're testing a different path in the stub code.  (This holds for
+// architectures with up to 10 register arguments, which covers all tier-1
+// platforms as of 2019.)
+
+function js_externref_stackarg(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, p) {
+    if (p !== objs[index])
+        throw new Error("Bad argument at " + index);
+}
+
+var ins1 = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (import "" "f" (func $f (param externref)))
+       (import "" "g" (func $g (param i32) (param i32) (param i32) (param i32) (param i32)
+                               (param i32) (param i32) (param i32) (param i32) (param i32)
+                               (param externref)))
+       (func (export "run1") (param externref) (result externref)
+         (call $f (local.get 0))
+         (local.get 0))
+       (func (export "run2") (param externref) (result externref)
+         (call $g (i32.const 0) (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4)
+                  (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8) (i32.const 9)
+                  (local.get 0))
+         (local.get 0)))`)),
+                                   {"":{f: js_externref_regarg, g: js_externref_stackarg}});
+
+index = 0;
+for ( let i=0; i < iter; i++ ) {
+    let res = ins1.exports.run1(objs[index]);
+    if (res !== objs[index])
+        throw new Error("Bad return at " + index);
+    index = (index + 1) % objs.length;
+}
+
+index = 0;
+for ( let i=0; i < iter; i++ ) {
+    let res = ins1.exports.run2(objs[index]);
+    if (res !== objs[index])
+        throw new Error("Bad return at " + index);
+    index = (index + 1) % objs.length;
+}
+
+// Test that:
+//
+//  * wasm->js calls along the fast path box JS values into externref correctly on
+//    return from JS.  This is tested by returing a value from JS through wasm
+//    back into JS and then checking that the object is the same as the one that
+//    was returned.
+
+function js_returns_externref(p) {
+    return objs[index];
+}
+
+var ins2 = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (import "" "f" (func $f (result externref)))
+       (import "" "g" (func $g (param externref)))
+       (func (export "run1") (result externref)
+         (local $tmp externref)
+         (local.set $tmp (call $f))
+         (call $g (local.get $tmp))
+         (local.get $tmp)))`)),
+                                    {"":{f: js_returns_externref, g: js_externref_regarg}});
+
+index = 0;
+for ( let i=0; i < iter; i++ ) {
+    let res = ins2.exports.run1();
+    if (res !== objs[index])
+        throw new Error("Bad return at " + index);
+    index = (index + 1) % objs.length;
+}
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref-global-object.js b/js/src/jit-test/tests/wasm/ref-types/externref-global-object.js
new file mode 100644
index 0000000000..806896e9b8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref-global-object.js
@@ -0,0 +1,91 @@
+// |jit-test| skip-if: typeof WebAssembly.Global !== 'function'
+
+// Dummy object.
+function Baguette(calories) {
+    this.calories = calories;
+}
+
+assertEq(new WebAssembly.Global({value: "externref"}) instanceof WebAssembly.Global, true);
+
+(function() {
+    // Test initialization without a value.
+    let g = new WebAssembly.Global({value: "externref"});
+    assertEq(g.value, void 0);
+    assertErrorMessage(() => g.value = 42, TypeError, /immutable global/);
+})();
+
+(function() {
+    // Test initialization with a value.
+    let g = new WebAssembly.Global({value: "externref"}, null);
+    assertEq(g.value, null);
+    assertErrorMessage(() => g.value = 42, TypeError, /immutable global/);
+
+    let obj = {};
+    g = new WebAssembly.Global({value: "externref"}, obj);
+    assertEq(g.value, obj);
+    assertErrorMessage(() => g.value = 42, TypeError, /immutable global/);
+
+    g = new WebAssembly.Global({value: "externref"}, 1337);
+    assertEq(typeof g.value, "number");
+    assertEq(+g.value, 1337);
+
+    g = new WebAssembly.Global({value: "externref"}, 13.37);
+    assertEq(typeof g.value, "number");
+    assertEq(+g.value, 13.37);
+
+    g = new WebAssembly.Global({value: "externref"}, "string");
+    assertEq(typeof g.value, "string");
+    assertEq(g.value.toString(), "string");
+
+    g = new WebAssembly.Global({value: "externref"}, true);
+    assertEq(typeof g.value, "boolean");
+    assertEq(!!g.value, true);
+
+    g = new WebAssembly.Global({value: "externref"}, Symbol("status"));
+    assertEq(typeof g.value, "symbol");
+    assertEq(g.value.toString(), "Symbol(status)");
+
+    g = new WebAssembly.Global({value: "externref"}, undefined);
+    assertEq(g.value, undefined);
+})();
+
+(function() {
+    // Test mutable property and assignment.
+    let g = new WebAssembly.Global({value: "externref", mutable: true}, null);
+    assertEq(g.value, null);
+
+    let obj = { x: 42 };
+    g.value = obj;
+    assertEq(g.value, obj);
+    assertEq(g.value.x, 42);
+
+    obj = null;
+    assertEq(g.value.x, 42);
+
+    let otherObj = { y : 35 };
+    g.value = otherObj;
+    assertEq(g.value, otherObj);
+})();
+
+(function() {
+    // Test tracing.
+    let nom = new Baguette(1);
+    let g = new WebAssembly.Global({value: "externref"}, nom);
+    nom = null;
+    gc();
+    assertEq(g.value.calories, 1);
+})();
+
+var global = new WebAssembly.Global({ value: "externref", mutable: true }, null);
+
+// GCZeal mode 2 implies that every allocation (second parameter = every single
+// allocation) will trigger a full GC.
+gczeal(2, 1);
+
+{
+    let nomnom = new Baguette(42);
+    global.value = nomnom;
+    nomnom = null;
+}
+new Baguette();
+assertEq(global.value.calories, 42);
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref-global-postbarrier.js b/js/src/jit-test/tests/wasm/ref-types/externref-global-postbarrier.js
new file mode 100644
index 0000000000..06d9521504
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref-global-postbarrier.js
@@ -0,0 +1,89 @@
+const { startProfiling, endProfiling, assertEqPreciseStacks, isSingleStepProfilingEnabled } = WasmHelpers;
+
+// Dummy constructor.
+function Baguette(calories) {
+    this.calories = calories;
+}
+
+// Ensure the baseline compiler sync's before the postbarrier.
+(function() {
+    wasmEvalText(`(module
+        (global (mut externref) (ref.null extern))
+        (func (export "f")
+            global.get 0
+            ref.null extern
+            global.set 0
+            global.set 0
+        )
+    )`).exports.f();
+})();
+
+let exportsPlain = wasmEvalText(`(module
+    (global i32 (i32.const 42))
+    (global $g (mut externref) (ref.null extern))
+    (func (export "set") (param externref) local.get 0 global.set $g)
+    (func (export "get") (result externref) global.get $g)
+)`).exports;
+
+let exportsObj = wasmEvalText(`(module
+    (global $g (export "g") (mut externref) (ref.null extern))
+    (func (export "set") (param externref) local.get 0 global.set $g)
+    (func (export "get") (result externref) global.get $g)
+)`).exports;
+
+// 7 => Generational GC zeal.
+gczeal(7, 1);
+
+for (var i = 0; i < 100; i++) {
+    new Baguette(i);
+}
+
+function test(exports) {
+    // Test post-write barrier in wasm code.
+    {
+        let nomnom = new Baguette(15);
+        exports.set(nomnom);
+        nomnom = null;
+    }
+    new Baguette();
+    assertEq(exports.get().calories, 15);
+}
+
+test(exportsPlain);
+test(exportsObj);
+
+// Test stacks reported in profiling mode in a separate way, to not perturb
+// the behavior of the tested functions.
+if (!isSingleStepProfilingEnabled)
+    quit(0);
+
+enableGeckoProfiling();
+
+const EXPECTED_STACKS = [
+    // Expected output for (simulator+baseline).
+    ['', '!>', '0,!>', '<,0,!>', 'GC postbarrier,0,!>',
+     '<,0,!>', '0,!>', '!>', ''],
+
+    // Expected output for (simulator+via-Ion).
+    ['', '!>', '0,!>', '<,0,!>', 'filtering GC postbarrier,0,!>',
+     '<,0,!>', '0,!>', '!>', ''],
+
+    // Expected output for other configurations.
+    ['', '!>', '0,!>', '!>', ''],
+];
+
+function testStacks(exports) {
+    // Test post-write barrier in wasm code.
+    {
+        let nomnom = new Baguette(15);
+        startProfiling();
+        exports.set(nomnom);
+        assertEqPreciseStacks(endProfiling(), EXPECTED_STACKS);
+        nomnom = null;
+    }
+    new Baguette();
+    assertEq(exports.get().calories, 15);
+}
+
+testStacks(exportsPlain);
+testStacks(exportsObj);
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref-global-prebarrier.js b/js/src/jit-test/tests/wasm/ref-types/externref-global-prebarrier.js
new file mode 100644
index 0000000000..139f71e758
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref-global-prebarrier.js
@@ -0,0 +1,61 @@
+// Do not run the test if we're jit-compiling JS, since it's the wasm frames
+// we're interested in and eager JS compilation can upset the test.
+
+opts = getJitCompilerOptions();
+if (opts['ion.enable'] || opts['baseline.enable'])
+  quit();
+
+const { startProfiling, endProfiling, assertEqPreciseStacks, isSingleStepProfilingEnabled } = WasmHelpers;
+
+let e = wasmEvalText(`(module
+    (global $g (mut externref) (ref.null extern))
+    (func (export "set") (param externref) local.get 0 global.set $g)
+)`).exports;
+
+let obj = { field: null };
+
+// GCZeal mode 4 implies that prebarriers are being verified at many
+// locations in the interpreter, during interrupt checks, etc. It can be ultra
+// slow, so disable it with gczeal(0) when it's not strictly needed.
+gczeal(4, 1);
+e.set(obj);
+e.set(null);
+gczeal(0);
+
+if (!isSingleStepProfilingEnabled) {
+    quit(0);
+}
+
+enableGeckoProfiling();
+startProfiling();
+gczeal(4, 1);
+e.set(obj);
+gczeal(0);
+assertEqPreciseStacks(
+    endProfiling(),
+    [
+        // Expected output for (simulator+via-Ion/baseline).
+        ['', '!>', '0,!>', '<,0,!>', 'GC postbarrier,0,!>',
+         '<,0,!>', '0,!>', '!>', ''],
+
+        // Expected output for other configurations.
+        ['', '!>', '0,!>', '!>', ''],
+    ]);
+
+startProfiling();
+gczeal(4, 1);
+e.set(null);
+gczeal(0);
+
+// We're losing stack info in the prebarrier code.
+assertEqPreciseStacks(
+    endProfiling(),
+    [
+        // Expected output for (simulator+via-Ion/baseline).
+        ['', '!>', '0,!>', '', '0,!>', '<,0,!>', 'GC postbarrier,0,!>',
+         '<,0,!>', '0,!>', '!>', ''],
+
+        // Expected output for other configurations.
+        ['', '!>', '0,!>', '', '0,!>', '!>', ''],
+    ]);
+
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref-val-tracing.js b/js/src/jit-test/tests/wasm/ref-types/externref-val-tracing.js
new file mode 100644
index 0000000000..3c7e596d12
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref-val-tracing.js
@@ -0,0 +1,10 @@
+gczeal(14, 1);
+let { exports } = wasmEvalText(`(module
+    (global $externref (import "glob" "externref") externref)
+    (func (export "get") (result externref) global.get $externref)
+)`, {
+    glob: {
+        externref: { sentinel: "lol" },
+    }
+});
+assertEq(exports.get().sentinel, "lol");
diff --git a/js/src/jit-test/tests/wasm/ref-types/externref.js b/js/src/jit-test/tests/wasm/ref-types/externref.js
new file mode 100644
index 0000000000..695279da73
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/externref.js
@@ -0,0 +1,482 @@
+// Dummy constructor.
+function Baguette(calories) {
+    this.calories = calories;
+}
+
+// Type checking.
+
+const { validate, CompileError } = WebAssembly;
+
+assertErrorMessage(() => wasmEvalText(`(module
+    (func (result externref)
+        i32.const 42
+    )
+)`), CompileError, mismatchError('i32', 'externref'));
+
+assertErrorMessage(() => wasmEvalText(`(module
+    (func (result externref)
+        i32.const 0
+        ref.null extern
+        i32.const 42
+        select (result externref)
+    )
+)`), CompileError, /type mismatch/);
+
+assertErrorMessage(() => wasmEvalText(`(module
+    (func (result i32)
+        ref.null extern
+        if
+            i32.const 42
+        end
+    )
+)`), CompileError, mismatchError('externref', 'i32'));
+
+
+// Basic compilation tests.
+
+let simpleTests = [
+    "(module (func (drop (ref.null extern))))",
+    "(module (func $test (local externref)))",
+    "(module (func $test (param externref)))",
+    "(module (func $test (result externref) (ref.null extern)))",
+    "(module (func $test (block (result externref) (unreachable)) unreachable))",
+    "(module (func $test (result i32) (local externref) (ref.is_null (local.get 0))))",
+    `(module (import "a" "b" (func (param externref))))`,
+    `(module (import "a" "b" (func (result externref))))`,
+    `(module (global externref (ref.null extern)))`,
+    `(module (global (mut externref) (ref.null extern)))`,
+];
+
+for (let src of simpleTests) {
+    wasmEvalText(src, {a:{b(){}}});
+    assertEq(validate(wasmTextToBinary(src)), true);
+}
+
+// Basic behavioral tests.
+
+let { exports } = wasmEvalText(`(module
+    (func (export "is_null") (result i32)
+        ref.null extern
+        ref.is_null
+    )
+
+    (func $sum (param i32) (result i32)
+        local.get 0
+        i32.const 42
+        i32.add
+    )
+
+    (func (export "is_null_spill") (result i32)
+        ref.null extern
+        i32.const 58
+        call $sum
+        drop
+        ref.is_null
+    )
+
+    (func (export "is_null_local") (result i32) (local externref)
+        ref.null extern
+        local.set 0
+        i32.const 58
+        call $sum
+        drop
+        local.get 0
+        ref.is_null
+    )
+    )`);
+
+assertEq(exports.is_null(), 1);
+assertEq(exports.is_null_spill(), 1);
+assertEq(exports.is_null_local(), 1);
+
+// ExternRef param and result in wasm functions.
+
+exports = wasmEvalText(`(module
+    (func (export "is_null") (param $ref externref) (result i32)
+        local.get $ref
+        ref.is_null
+    )
+
+    (func (export "ref_or_null") (param $ref externref) (param $selector i32) (result externref)
+        local.get $ref
+        ref.null extern
+        local.get $selector
+        select (result externref)
+    )
+
+    (func $recursive (export "nested") (param $ref externref) (param $i i32) (result externref)
+        ;; i == 10 => ret $ref
+        local.get $i
+        i32.const 10
+        i32.eq
+        if
+            local.get $ref
+            return
+        end
+
+        local.get $ref
+
+        local.get $i
+        i32.const 1
+        i32.add
+
+        call $recursive
+    )
+)`).exports;
+
+assertEq(exports.is_null(undefined), 0);
+assertEq(exports.is_null(null), 1);
+assertEq(exports.is_null({}), 0);
+assertEq(exports.is_null("hi"), 0);
+assertEq(exports.is_null(3), 0);
+assertEq(exports.is_null(3.5), 0);
+assertEq(exports.is_null(true), 0);
+assertEq(exports.is_null(Symbol("croissant")), 0);
+assertEq(exports.is_null(new Baguette(100)), 0);
+
+let baguette = new Baguette(42);
+assertEq(exports.ref_or_null(null, 0), null);
+assertEq(exports.ref_or_null(baguette, 0), null);
+
+let ref = exports.ref_or_null(baguette, 1);
+assertEq(ref, baguette);
+assertEq(ref.calories, baguette.calories);
+
+ref = exports.nested(baguette, 0);
+assertEq(ref, baguette);
+assertEq(ref.calories, baguette.calories);
+
+// Make sure grow-memory isn't blocked by the lack of gc.
+(function() {
+    assertEq(wasmEvalText(`(module
+    (memory 0 64)
+    (func (export "f") (param externref) (result i32)
+        i32.const 10
+        memory.grow
+        drop
+        memory.size
+    )
+)`).exports.f({}), 10);
+})();
+
+// More interesting use cases about control flow joins.
+
+function assertJoin(body) {
+    let val = { i: -1 };
+    assertEq(wasmEvalText(`(module
+        (func (export "test") (param $ref externref) (param $i i32) (result externref)
+            ${body}
+        )
+    )`).exports.test(val), val);
+    assertEq(val.i, -1);
+}
+
+assertJoin("(block (result externref) local.get $ref)");
+assertJoin("(block $out (result externref) local.get $ref br $out)");
+assertJoin("(loop (result externref) local.get $ref)");
+
+assertJoin(`(block $out (result externref) (loop $top (result externref)
+    local.get $i
+    i32.const 1
+    i32.add
+    tee_local $i
+    i32.const 10
+    i32.eq
+    if
+        local.get $ref
+        return
+    end
+    br $top))
+`);
+
+assertJoin(`(block $out (loop $top
+    local.get $i
+    i32.const 1
+    i32.add
+    tee_local $i
+    i32.const 10
+    i32.le_s
+    if
+        br $top
+    else
+        local.get $ref
+        return
+    end
+    )) unreachable
+`);
+
+assertJoin(`(block $out (result externref) (loop $top
+    local.get $ref
+    local.get $i
+    i32.const 1
+    i32.add
+    tee_local $i
+    i32.const 10
+    i32.eq
+    br_if $out
+    br $top
+    ) unreachable)
+`);
+
+assertJoin(`(block $out (result externref) (block $unreachable (result externref) (loop $top
+    local.get $ref
+    local.get $i
+    i32.const 1
+    i32.add
+    tee_local $i
+    br_table $unreachable $out
+    ) unreachable))
+`);
+
+let x = { i: 42 }, y = { f: 53 };
+exports = wasmEvalText(`(module
+    (func (export "test") (param $lhs externref) (param $rhs externref) (param $i i32) (result externref)
+        local.get $lhs
+        local.get $rhs
+        local.get $i
+        select (result externref)
+    )
+)`).exports;
+
+let result = exports.test(x, y, 0);
+assertEq(result, y);
+assertEq(result.i, undefined);
+assertEq(result.f, 53);
+assertEq(x.i, 42);
+
+result = exports.test(x, y, 1);
+assertEq(result, x);
+assertEq(result.i, 42);
+assertEq(result.f, undefined);
+assertEq(y.f, 53);
+
+// ExternRef in params/result of imported functions.
+
+let firstBaguette = new Baguette(13),
+    secondBaguette = new Baguette(37);
+
+let imports = {
+    i: 0,
+    myBaguette: null,
+    funcs: {
+        param(x) {
+            if (this.i === 0) {
+                assertEq(x, firstBaguette);
+                assertEq(x.calories, 13);
+                assertEq(secondBaguette !== null, true);
+            } else if (this.i === 1 || this.i === 2) {
+                assertEq(x, secondBaguette);
+                assertEq(x.calories, 37);
+                assertEq(firstBaguette !== null, true);
+            } else if (this.i === 3) {
+                assertEq(x, null);
+            } else {
+                firstBaguette = null;
+                secondBaguette = null;
+                gc(); // evil mode
+            }
+            this.i++;
+        },
+        ret() {
+            return imports.myBaguette;
+        }
+    }
+};
+
+exports = wasmEvalText(`(module
+    (import "funcs" "ret" (func $ret (result externref)))
+    (import "funcs" "param" (func $param (param externref)))
+
+    (func (export "param") (param $x externref) (param $y externref)
+        local.get $y
+        local.get $x
+        call $param
+        call $param
+    )
+
+    (func (export "ret") (result externref)
+        call $ret
+    )
+)`, imports).exports;
+
+exports.param(firstBaguette, secondBaguette);
+exports.param(secondBaguette, null);
+exports.param(firstBaguette, secondBaguette);
+
+imports.myBaguette = null;
+assertEq(exports.ret(), null);
+
+imports.myBaguette = new Baguette(1337);
+assertEq(exports.ret(), imports.myBaguette);
+
+// Check lazy stubs generation.
+
+exports = wasmEvalText(`(module
+    (import "funcs" "mirror" (func $mirror (param externref) (result externref)))
+    (import "funcs" "augment" (func $augment (param externref) (result externref)))
+
+    (global $count_f (mut i32) (i32.const 0))
+    (global $count_g (mut i32) (i32.const 0))
+
+    (func $f (param $param externref) (result externref)
+        i32.const 1
+        global.get $count_f
+        i32.add
+        global.set $count_f
+
+        local.get $param
+        call $augment
+    )
+
+    (func $g (param $param externref) (result externref)
+        i32.const 1
+        global.get $count_g
+        i32.add
+        global.set $count_g
+
+        local.get $param
+        call $mirror
+    )
+
+    (table (export "table") 10 funcref)
+    (elem (i32.const 0) $f $g $mirror $augment)
+    (type $table_type (func (param externref) (result externref)))
+
+    (func (export "call_indirect") (param $i i32) (param $ref externref) (result externref)
+        local.get $ref
+        local.get $i
+        call_indirect (type $table_type)
+    )
+
+    (func (export "count_f") (result i32) global.get $count_f)
+    (func (export "count_g") (result i32) global.get $count_g)
+)`, {
+    funcs: {
+        mirror(x) {
+            return x;
+        },
+        augment(x) {
+            x.i++;
+            x.newProp = "hello";
+            return x;
+        }
+    }
+}).exports;
+
+x = { i: 19 };
+assertEq(exports.table.get(0)(x), x);
+assertEq(x.i, 20);
+assertEq(x.newProp, "hello");
+assertEq(exports.count_f(), 1);
+assertEq(exports.count_g(), 0);
+
+x = { i: 21 };
+assertEq(exports.table.get(1)(x), x);
+assertEq(x.i, 21);
+assertEq(typeof x.newProp, "undefined");
+assertEq(exports.count_f(), 1);
+assertEq(exports.count_g(), 1);
+
+x = { i: 22 };
+assertEq(exports.table.get(2)(x), x);
+assertEq(x.i, 22);
+assertEq(typeof x.newProp, "undefined");
+assertEq(exports.count_f(), 1);
+assertEq(exports.count_g(), 1);
+
+x = { i: 23 };
+assertEq(exports.table.get(3)(x), x);
+assertEq(x.i, 24);
+assertEq(x.newProp, "hello");
+assertEq(exports.count_f(), 1);
+assertEq(exports.count_g(), 1);
+
+// Globals.
+
+// ExternRef globals in wasm modules.
+
+assertErrorMessage(() => wasmEvalText(`(module (global (import "glob" "externref") externref))`, { glob: { externref: new WebAssembly.Global({ value: 'i32' }, 42) } }),
+    WebAssembly.LinkError,
+    /imported global type mismatch/);
+
+assertErrorMessage(() => wasmEvalText(`(module (global (import "glob" "i32") i32))`, { glob: { i32: {} } }),
+    WebAssembly.LinkError,
+    /import object field 'i32' is not a Number/);
+
+imports = {
+    constants: {
+        imm_null: null,
+        imm_bread: new Baguette(321),
+        mut_null: new WebAssembly.Global({ value: "externref", mutable: true }, null),
+        mut_bread: new WebAssembly.Global({ value: "externref", mutable: true }, new Baguette(123))
+    }
+};
+
+exports = wasmEvalText(`(module
+    (global $g_imp_imm_null  (import "constants" "imm_null") externref)
+    (global $g_imp_imm_bread (import "constants" "imm_bread") externref)
+
+    (global $g_imp_mut_null   (import "constants" "mut_null") (mut externref))
+    (global $g_imp_mut_bread  (import "constants" "mut_bread") (mut externref))
+
+    (global $g_imm_null     externref (ref.null extern))
+    (global $g_imm_getglob  externref (global.get $g_imp_imm_bread))
+    (global $g_mut         (mut externref) (ref.null extern))
+
+    (func (export "imm_null")      (result externref) global.get $g_imm_null)
+    (func (export "imm_getglob")   (result externref) global.get $g_imm_getglob)
+
+    (func (export "imp_imm_null")  (result externref) global.get $g_imp_imm_null)
+    (func (export "imp_imm_bread") (result externref) global.get $g_imp_imm_bread)
+    (func (export "imp_mut_null")  (result externref) global.get $g_imp_mut_null)
+    (func (export "imp_mut_bread") (result externref) global.get $g_imp_mut_bread)
+
+    (func (export "set_imp_null")  (param externref) local.get 0 global.set $g_imp_mut_null)
+    (func (export "set_imp_bread") (param externref) local.get 0 global.set $g_imp_mut_bread)
+
+    (func (export "set_mut") (param externref) local.get 0 global.set $g_mut)
+    (func (export "get_mut") (result externref) global.get $g_mut)
+)`, imports).exports;
+
+assertEq(exports.imp_imm_null(), imports.constants.imm_null);
+assertEq(exports.imp_imm_bread(), imports.constants.imm_bread);
+
+assertEq(exports.imm_null(), null);
+assertEq(exports.imm_getglob(), imports.constants.imm_bread);
+
+assertEq(exports.imp_mut_null(), imports.constants.mut_null.value);
+assertEq(exports.imp_mut_bread(), imports.constants.mut_bread.value);
+
+let brandNewBaguette = new Baguette(1000);
+exports.set_imp_null(brandNewBaguette);
+assertEq(exports.imp_mut_null(), brandNewBaguette);
+assertEq(exports.imp_mut_bread(), imports.constants.mut_bread.value);
+
+exports.set_imp_bread(null);
+assertEq(exports.imp_mut_null(), brandNewBaguette);
+assertEq(exports.imp_mut_bread(), null);
+
+assertEq(exports.get_mut(), null);
+let glutenFreeBaguette = new Baguette("calories-free bread");
+exports.set_mut(glutenFreeBaguette);
+assertEq(exports.get_mut(), glutenFreeBaguette);
+assertEq(exports.get_mut().calories, "calories-free bread");
+
+// Make sure that dead code doesn't prevent compilation.
+wasmEvalText(
+    `(module
+       (func
+         (return)
+         (ref.null extern)
+         (drop)
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (func (param externref)
+         (return)
+         (ref.is_null (get_local 0))
+         (drop)
+        )
+    )`);
diff --git a/js/src/jit-test/tests/wasm/ref-types/funcref-fastpaths.js b/js/src/jit-test/tests/wasm/ref-types/funcref-fastpaths.js
new file mode 100644
index 0000000000..1650deda3f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/funcref-fastpaths.js
@@ -0,0 +1,76 @@
+// Test the fast paths along which funcref values flow between wasm and JS.
+// Currently, these paths always go from wasm into JS; never from JS into wasm.
+
+setJitCompilerOption("baseline.warmup.trigger", 5);
+setJitCompilerOption("ion.warmup.trigger", 10);
+
+var iter = 10000;
+var objs = [];
+var index = 0;
+
+var ins0 = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+      (func $f (export "f") (result i32) (i32.const 37))
+      (func $g (export "g") (result i32) (i32.const 42)))`)));
+objs.push(ins0.exports.f);
+objs.push(ins0.exports.g);
+
+// Tests that:
+//
+//  * wasm->js calls along the fast path pass funcref correctly on entry to JS.
+//    This is tested by JS observing that the value that it receives is the same
+//    that was passed into wasm in the first place.
+//
+//  * js->wasm calls along the fast path pass funcref correctly on return from
+//    wasm.  This is tested by returning the passed-in value and observing in
+//    JS that the value is the same as the value that was passed in.
+
+// `p` will be a register argument on most platforms.
+
+function js_funcref_regarg(p) {
+    if (p !== objs[index])
+        throw new Error("Bad argument at " + index);
+}
+
+// `p` will be a stack argument on all platforms.  In the internal ABI, the
+// funcref parameter ends up in a stack slot in the call to js_funcref_stackarg,
+// thus we're testing a different path in the stub code.  (This holds for
+// architectures with up to 10 register arguments, which covers all tier-1
+// platforms as of 2019.)
+
+function js_funcref_stackarg(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, p) {
+    if (p !== objs[index])
+        throw new Error("Bad argument at " + index);
+}
+
+var ins1 = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (import "" "f" (func $f (param funcref)))
+       (import "" "g" (func $g (param i32) (param i32) (param i32) (param i32) (param i32)
+                               (param i32) (param i32) (param i32) (param i32) (param i32)
+                               (param funcref)))
+       (func (export "run1") (param funcref) (result funcref)
+         (call $f (local.get 0))
+         (local.get 0))
+       (func (export "run2") (param funcref) (result funcref)
+         (call $g (i32.const 0) (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4)
+                  (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8) (i32.const 9)
+                  (local.get 0))
+         (local.get 0)))`)),
+                                   {"":{f: js_funcref_regarg, g: js_funcref_stackarg}});
+
+index = 0;
+for ( let i=0; i < iter; i++ ) {
+    let res = ins1.exports.run1(objs[index]);
+    if (res !== objs[index])
+        throw new Error("Bad return at " + index);
+    index = (index + 1) % objs.length;
+}
+
+index = 0;
+for ( let i=0; i < iter; i++ ) {
+    let res = ins1.exports.run2(objs[index]);
+    if (res !== objs[index])
+        throw new Error("Bad return at " + index);
+    index = (index + 1) % objs.length;
+}
diff --git a/js/src/jit-test/tests/wasm/ref-types/funcref.js b/js/src/jit-test/tests/wasm/ref-types/funcref.js
new file mode 100644
index 0000000000..21ce95c0cb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/funcref.js
@@ -0,0 +1,135 @@
+const {Module,Instance,Global,RuntimeError} = WebAssembly;
+
+const badWasmFunc = /can only pass WebAssembly exported functions to funcref/;
+const typeErr = /type mismatch/;
+
+
+// Validation:
+
+wasmFailValidateText(`(module (func (local externref funcref) (local.set 0 (local.get 1))))`, typeErr);
+wasmEvalText(`(module (func (local funcref funcref) (local.set 0 (local.get 1))))`);
+wasmEvalText(`(module (func (local funcref) (local.set 0 (ref.null func))))`);
+wasmFailValidateText(`(module (func (local funcref externref) (local.set 0 (local.get 1))))`, typeErr);
+wasmEvalText(`(module (global (mut funcref) (ref.null func)) (func (param funcref) (global.set 0 (local.get 0))))`);
+wasmFailValidateText(`(module (global (mut externref) (ref.null extern)) (func (param funcref) (global.set 0 (local.get 0))))`, typeErr);
+wasmFailValidateText(`(module (global (mut funcref) (ref.null func)) (func (param externref) (global.set 0 (local.get 0))))`, typeErr);
+wasmEvalText(`(module (func (param funcref)) (func (param funcref) (call 0 (local.get 0))))`);
+wasmFailValidateText(`(module (func (param externref)) (func (param funcref) (call 0 (local.get 0))))`, typeErr);
+wasmFailValidateText(`(module (func (param funcref)) (func (param externref) (call 0 (local.get 0))))`, typeErr);
+wasmEvalText(`(module (func (param funcref) (result funcref) (block (result funcref) (local.get 0) (br 0))))`);
+wasmFailValidateText(`(module (func (param funcref) (result externref) (block (result externref) (local.get 0) (br 0))))`, typeErr);
+wasmFailValidateText(`(module (func (param externref) (result externref) (block (result funcref) (local.get 0) (br 0))))`, typeErr);
+wasmEvalText(`(module (func (param funcref funcref) (result funcref) (select (result funcref) (local.get 0) (local.get 1) (i32.const 0))))`);
+wasmFailValidateText(`(module (func (param externref funcref) (result externref) (select (result externref) (local.get 0) (local.get 1) (i32.const 0))))`, typeErr);
+wasmFailValidateText(`(module (func (param funcref externref) (result externref) (select (result externref)(local.get 0) (local.get 1) (i32.const 0))))`, typeErr);
+wasmFailValidateText(`(module (func (param externref funcref) (result funcref) (select (result funcref) (local.get 0) (local.get 1) (i32.const 0))))`, typeErr);
+wasmFailValidateText(`(module (func (param funcref externref) (result funcref) (select (result funcref) (local.get 0) (local.get 1) (i32.const 0))))`, typeErr);
+
+
+// Runtime:
+
+var m = new Module(wasmTextToBinary(`(module (func (export "wasmFun")))`));
+const wasmFun1 = new Instance(m).exports.wasmFun;
+const wasmFun2 = new Instance(m).exports.wasmFun;
+const wasmFun3 = new Instance(m).exports.wasmFun;
+
+var run = wasmEvalText(`(module
+    (global (mut funcref) (ref.null func))
+    (func (param $x funcref) (param $test i32) (result funcref)
+      local.get $x
+      global.get 0
+      local.get $test
+      select (result funcref)
+    )
+    (func (export "run") (param $a funcref) (param $b funcref) (param $c funcref) (param $test1 i32) (param $test2 i32) (result funcref)
+      local.get $a
+      global.set 0
+      block (result funcref)
+        local.get $b
+        local.get $test1
+        br_if 0
+        drop
+        local.get $c
+      end
+      local.get $test2
+      call 0
+    )
+)`).exports.run;
+assertEq(run(wasmFun1, wasmFun2, wasmFun3, false, false), wasmFun1);
+assertEq(run(wasmFun1, wasmFun2, wasmFun3, true, false), wasmFun1);
+assertEq(run(wasmFun1, wasmFun2, wasmFun3, true, true), wasmFun2);
+assertEq(run(wasmFun1, wasmFun2, wasmFun3, false, true), wasmFun3);
+
+var run = wasmEvalText(`(module
+  (type $t0 (func (param externref) (result externref)))
+  (type $t1 (func (param funcref) (result externref)))
+  (type $t2 (func (param funcref funcref) (result externref)))
+  (func $f0 (type $t0) ref.null extern)
+  (func $f1 (type $t1) ref.null extern)
+  (func $f2 (type $t2) ref.null extern)
+  (table funcref (elem $f0 $f1 $f2))
+  (func (export "run") (param i32 i32) (result externref)
+    block $b2 block $b1 block $b0
+      local.get 0
+      br_table $b0 $b1 $b2
+    end $b0
+      ref.null extern
+      local.get 1
+      call_indirect (type $t0)
+      return
+    end $b1
+      ref.null func
+      local.get 1
+      call_indirect (type $t1)
+      return
+    end $b2
+      ref.null func
+      ref.null func
+      local.get 1
+      call_indirect (type $t2)
+      return
+  )
+)`).exports.run;
+
+for (var i = 0; i < 3; i++) {
+  for (var j = 0; j < 3; j++) {
+    if (i == j)
+      assertEq(run(i, j), null);
+    else
+      assertErrorMessage(() => run(i, j), RuntimeError, /indirect call signature mismatch/);
+  }
+}
+
+
+// JS API:
+
+const wasmFun = wasmEvalText(`(module (func (export "x")))`).exports.x;
+
+var run = wasmEvalText(`(module (func (export "run") (param funcref) (result funcref) (local.get 0)))`).exports.run;
+assertEq(run(wasmFun), wasmFun);
+assertEq(run(null), null);
+assertErrorMessage(() => run(() => {}), TypeError, badWasmFunc);
+
+var importReturnValue;
+var importFun = () => importReturnValue;
+var run = wasmEvalText(`(module (func (import "" "i") (result funcref)) (func (export "run") (result funcref) (call 0)))`, {'':{i:importFun}}).exports.run;
+importReturnValue = wasmFun;
+assertEq(run(), wasmFun);
+importReturnValue = null;
+assertEq(run(), null);
+importReturnValue = undefined;
+assertErrorMessage(() => run(), TypeError, badWasmFunc);
+importReturnValue = () => {};
+assertErrorMessage(() => run(), TypeError, badWasmFunc);
+
+var g = new Global({value:'anyfunc', mutable:true}, wasmFun);
+assertEq(g.value, wasmFun);
+g.value = null;
+assertEq(g.value, null);
+Math.sin();
+assertErrorMessage(() => g.value = () => {}, TypeError, badWasmFunc);
+var g = new Global({value:'anyfunc', mutable:true}, null);
+assertEq(g.value, null);
+g.value = wasmFun;
+assertEq(g.value, wasmFun);
+assertErrorMessage(() => new Global({value:'anyfunc'}, () => {}), TypeError, badWasmFunc);
diff --git a/js/src/jit-test/tests/wasm/ref-types/fuzz-gc-while-allocating-global.js b/js/src/jit-test/tests/wasm/ref-types/fuzz-gc-while-allocating-global.js
new file mode 100644
index 0000000000..0b51622397
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/fuzz-gc-while-allocating-global.js
@@ -0,0 +1,3 @@
+enableShellAllocationMetadataBuilder();
+gczeal(9, 1);
+new WebAssembly.Global({ value: 'i32' }, 42);
diff --git a/js/src/jit-test/tests/wasm/ref-types/ref-func.js b/js/src/jit-test/tests/wasm/ref-types/ref-func.js
new file mode 100644
index 0000000000..de874669b3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/ref-func.js
@@ -0,0 +1,290 @@
+load(libdir + "wasm-binary.js");
+
+const v2vSig = {args:[], ret:VoidCode};
+const v2vSigSection = sigSection([v2vSig]);
+
+// 'ref.func' parses, validates and returns a non-null value
+wasmFullPass(`
+	(module
+		(elem declare $run)
+		(func $run (result i32)
+			ref.func $run
+			ref.is_null
+		)
+		(export "run" (func $run))
+	)
+`, 0);
+
+// function returning reference to itself
+{
+	let {f1} = wasmEvalText(`
+		(module
+			(elem declare $f1)
+			(func $f1 (result funcref) ref.func $f1)
+			(export "f1" (func $f1))
+		)
+	`).exports;
+	assertEq(f1(), f1);
+}
+
+// function returning reference to a different function
+{
+	let {f1, f2} = wasmEvalText(`
+		(module
+			(elem declare $f1)
+			(func $f1)
+			(func $f2 (result funcref) ref.func $f1)
+			(export "f1" (func $f1))
+			(export "f2" (func $f2))
+		)
+	`).exports;
+	assertEq(f2(), f1);
+}
+
+// function returning reference to function in a different module
+{
+	let i1 = wasmEvalText(`
+		(module
+			(elem declare $f1)
+			(func $f1)
+			(export "f1" (func $f1))
+		)
+	`);
+	let i2 = wasmEvalText(`
+		(module
+			(import "" "f1" (func $f1))
+			(elem declare $f1)
+			(func $f2 (result funcref) ref.func $f1)
+			(export "f1" (func $f1))
+			(export "f2" (func $f2))
+		)
+	`, {"": i1.exports});
+
+	let f1 = i1.exports.f1;
+	let f2 = i2.exports.f2;
+	assertEq(f2(), f1);
+}
+
+// function index must be valid
+assertErrorMessage(() => {
+	wasmEvalText(`
+		(module
+			(func (result funcref) ref.func 10)
+		)
+	`);
+}, WebAssembly.CompileError, /(function index out of range)|(function index out of bounds)/);
+
+function validFuncRefText(forwardDeclare, tbl_type) {
+	return wasmEvalText(`
+		(module
+			(table 1 ${tbl_type})
+			(func $test (result funcref) ref.func $referenced)
+			(func $referenced)
+			${forwardDeclare}
+		)
+	`);
+}
+
+// referenced function must be forward declared somehow
+assertErrorMessage(() => validFuncRefText('', 'funcref'), WebAssembly.CompileError, /(function index is not declared in a section before the code section)|(undeclared function reference)/);
+
+// referenced function can be forward declared via segments
+assertEq(validFuncRefText('(elem 0 (i32.const 0) func $referenced)', 'funcref') instanceof WebAssembly.Instance, true);
+assertEq(validFuncRefText('(elem func $referenced)', 'funcref') instanceof WebAssembly.Instance, true);
+assertEq(validFuncRefText('(elem declare $referenced)', 'funcref') instanceof WebAssembly.Instance, true);
+
+// also when the segment is passive or active 'funcref'
+assertEq(validFuncRefText('(elem 0 (i32.const 0) funcref (ref.func $referenced))', 'funcref') instanceof WebAssembly.Instance, true);
+assertEq(validFuncRefText('(elem funcref (ref.func $referenced))', 'funcref') instanceof WebAssembly.Instance, true);
+
+// reference function can be forward declared via globals
+assertEq(validFuncRefText('(global funcref (ref.func $referenced))', 'externref') instanceof WebAssembly.Instance, true);
+
+// reference function can be forward declared via export
+assertEq(validFuncRefText('(export "referenced" (func $referenced))', 'externref') instanceof WebAssembly.Instance, true);
+
+// reference function cannot be forward declared via start
+assertErrorMessage(() => validFuncRefText('(start $referenced)', 'externref'), WebAssembly.CompileError, /(function index is not declared in a section before the code section)|(undeclared function reference)/);
+
+// Tests not expressible in the text format.
+
+// element segment with elemexpr can carry non-reference type, but this must be
+// rejected.
+
+assertErrorMessage(() => new WebAssembly.Module(
+    moduleWithSections([generalElemSection([{ flag: PassiveElemExpr,
+                                              typeCode: I32Code,
+                                              elems: [] }])])),
+                   WebAssembly.CompileError,
+                   /bad type/);
+
+// Test case for bug 1596026: when taking the ref.func of an imported function,
+// the value obtained should not be the JS function.  This would assert (even in
+// a release build), so the test is merely that the code runs.
+
+var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+  (module
+    (import "m" "f" (func $f (param i32) (result i32)))
+    (elem declare $f)
+    (table 1 funcref)
+    (func (export "f")
+      (table.set 0 (i32.const 0) (ref.func $f))))`)),
+                                   {m:{f:(x) => 37+x}});
+ins.exports.f();
+
+// Verification that we can handle encoding errors for passive element segments
+// properly.
+
+function checkPassiveElemSegment(mangle, err) {
+    let bin = moduleWithSections(
+        [v2vSigSection, declSection([0]), // One function
+         tableSection(1),                 // One table
+         { name: elemId,                  // One passive segment
+           body: (function () {
+               let body = [];
+               body.push(1);           // 1 element segment
+               body.push(0x1 | 0x4);   // Flags: Passive and uses element expression
+               body.push(AnyFuncCode + (mangle == "type" ? 1 : 0)); // always anyfunc
+               body.push(1);           // Element count
+               body.push(RefFuncCode + (mangle == "ref.func" ? 1 : 0)); // always ref.func
+               body.push(0);           // func index
+               body.push(EndCode + (mangle == "end" ? 1 : 0));
+               return body;
+           })() },
+         bodySection(                   // Empty function
+             [funcBody(
+                 {locals:[],
+                  body:[]})])
+        ]);
+    if (err) {
+        assertErrorMessage(() => new WebAssembly.Module(bin),
+                           WebAssembly.CompileError,
+                           err);
+    } else {
+        new WebAssembly.Module(bin);
+    }
+}
+
+checkPassiveElemSegment("");
+checkPassiveElemSegment("type", /bad type/);
+checkPassiveElemSegment("ref.func", /failed to read initializer operation/);
+checkPassiveElemSegment("end", /failed to read end of initializer expression/);
+
+// Passive element segments can contain literal null values.
+
+{
+    let txt =
+        `(module
+           (table (export "t") 10 funcref)
+           (elem (i32.const 1) $m)
+           (elem (i32.const 3) $m)
+           (elem (i32.const 6) $m)
+           (elem (i32.const 8) $m)
+           (elem funcref (ref.func $f) (ref.null func) (ref.func $g) (ref.null func) (ref.func $h))
+           (func $m)
+           (func $f)
+           (func $g)
+           (func $h)
+           (func (export "doit") (param $idx i32)
+             (table.init 4 (local.get $idx) (i32.const 0) (i32.const 5))))`;
+    let ins = wasmEvalText(txt);
+    ins.exports.doit(0);
+    ins.exports.doit(5);
+    assertEq(typeof ins.exports.t.get(0), "function");
+    assertEq(ins.exports.t.get(1), null);
+    assertEq(typeof ins.exports.t.get(2), "function");
+    assertEq(ins.exports.t.get(0) == ins.exports.t.get(2), false);
+    assertEq(ins.exports.t.get(3), null);
+    assertEq(typeof ins.exports.t.get(4), "function");
+    assertEq(typeof ins.exports.t.get(5), "function");
+    assertEq(ins.exports.t.get(6), null);
+    assertEq(typeof ins.exports.t.get(7), "function");
+    assertEq(ins.exports.t.get(8), null);
+    assertEq(typeof ins.exports.t.get(9), "function");
+}
+
+// Test ref.func in global initializer expressions
+
+for (let mutable of [true, false]) {
+  for (let imported of [true, false]) {
+    for (let exported of [true, false]) {
+      let globalType = mutable ? `(mut funcref)` : `funcref`;
+
+      let imports = {};
+
+      if (imported) {
+        imports = wasmEvalText(`
+          (module
+            (global $g (export "g") ${globalType} (ref.func $f))
+            (func $f (export "f") (result i32) i32.const 42)
+          )
+        `).exports;
+      }
+
+      let exports = wasmEvalText(`
+        (module
+          (global $g ${exported ? `(export "g")` : ``} ${imported ? `(import "" "g")` : ``} ${globalType} ${imported ? `` : `(ref.func $f)`})
+          ${exported ? `` : `(func (export "get_g") (result funcref) global.get $g)`}
+          (func $f (export "f") (result i32) i32.const 42)
+        )
+      `, { "": imports }).exports;
+
+      let targetFunc = imported ? imports.f : exports.f;
+      let globalVal = exported ? exports.g.value : exports.get_g();
+      assertEq(targetFunc(), 42);
+      assertEq(globalVal(), 42);
+      assertEq(targetFunc, globalVal);
+      if (imported && exported) {
+        assertEq(imports.g, exports.g);
+      }
+    }
+  }
+}
+
+// Test invalid ref.func indices
+
+function testCodeRefFuncIndex(index) {
+  assertErrorMessage(() => {
+      new WebAssembly.Module(moduleWithSections(
+        [v2vSigSection,
+         declSection([0]), // One function
+         bodySection(
+          [funcBody(
+              {locals:[],
+               body:[
+                 RefFuncCode,
+                 ...varU32(index),
+                 DropCode
+                 ]})])
+          ]))
+    },
+    WebAssembly.CompileError,
+    /(function index out of range)|(function index out of bounds)/);
+}
+
+testCodeRefFuncIndex(1);
+testCodeRefFuncIndex(2);
+testCodeRefFuncIndex(10);
+testCodeRefFuncIndex(1000);
+
+function testGlobalRefFuncIndex(index) {
+  assertErrorMessage(() => {
+      new WebAssembly.Module(moduleWithSections(
+        [v2vSigSection,
+          globalSection([
+           {
+             valType: AnyFuncCode,
+             flags: 0,
+             initExpr: [RefFuncCode, ...varU32(index), EndCode],
+           }
+         ])
+        ]))
+    },
+    WebAssembly.CompileError,
+    /(function index out of range)|(function index out of bounds)/);
+}
+
+testGlobalRefFuncIndex(1);
+testGlobalRefFuncIndex(2);
+testGlobalRefFuncIndex(10);
+testGlobalRefFuncIndex(1000);
diff --git a/js/src/jit-test/tests/wasm/ref-types/stackmaps1.js b/js/src/jit-test/tests/wasm/ref-types/stackmaps1.js
new file mode 100644
index 0000000000..0776b490b2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/stackmaps1.js
@@ -0,0 +1,85 @@
+// Tests wasm frame tracing.  Only tests for direct and indirect call chains
+// in wasm that lead to JS allocation.  Does not test any timeout or interrupt
+// related aspects.  The structure is
+//
+//   test top level: call fn2
+//   fn2: call fn1
+//   fn1: do 100k times { call-direct fn0; call-indirect fn0; }
+//   fn0: call out to JS that does allocation
+//
+// Eventually fn0 will trigger GC and we expect the chain of resulting frames
+// to be traced correctly.  fn2, fn1 and fn0 have some ref-typed args, so
+// there will be traceable stack words to follow, in the sequence of frames.
+
+const {Module,Instance} = WebAssembly;
+
+let t =
+  `(module
+     (import "" "check3" (func $check3 (param externref) (param externref) (param externref)))
+     (import "" "alloc" (func $alloc (result externref)))
+     (type $typeOfFn0
+           (func (param i32) (param externref) (param i32)
+                 (param externref) (param externref) (param i32) (result i32)))
+     (table 1 1 funcref)
+     (elem (i32.const 0) $fn0)
+
+     ;; -- fn 0
+     (func $fn0 (export "fn0")
+                 (param $arg1 i32) (param $arg2 externref) (param $arg3 i32)
+                 (param $arg4 externref) (param $arg5 externref) (param $arg6 i32) (result i32)
+       (call $alloc)
+       drop
+       (i32.add (i32.add (local.get $arg1) (local.get $arg3)) (local.get $arg6))
+
+       ;; Poke the ref-typed arguments, to be sure that they got kept alive
+       ;; properly across any GC that the |alloc| call might have done.
+       (call $check3 (local.get $arg2) (local.get $arg4) (local.get $arg5))
+     )
+
+     ;; -- fn 1
+     (func $fn1 (export "fn1") (param $arg1 externref) (result i32)
+       (local $i i32)
+
+       (loop (result i32)
+         ;; call direct 0
+         (call $fn0 (i32.const 10) (local.get $arg1) (i32.const 12)
+                    (local.get $arg1) (local.get $arg1) (i32.const 15))
+
+         ;; call indirect 0
+         (call_indirect (type $typeOfFn0)
+                    (i32.const 10) (local.get $arg1) (i32.const 12)
+                    (local.get $arg1) (local.get $arg1) (i32.const 15)
+                    (i32.const 0)) ;; table index
+
+         i32.add
+
+         ;; Do 60k iterations of this loop, to get a good amount of allocation
+         (local.set $i (i32.add (local.get $i) (i32.const 1)))
+         (br_if 0 (i32.lt_s (local.get $i) (i32.const 60000)))
+       )
+     )
+
+     ;; -- fn 2
+     (func $fn2 (export "fn2") (param $arg1 externref) (result i32)
+       (call $fn1 (local.get $arg1))
+     )
+   )`;
+
+function Croissant(chocolate, number) {
+    this.chocolate = chocolate;
+    this.number = number;
+}
+
+function allocates() {
+    return new Croissant(true, 271828);
+}
+
+function check3(a1, a2, a3) {
+    assertEq(a1.number, 31415927);
+    assertEq(a2.number, 31415927);
+    assertEq(a3.number, 31415927);
+}
+
+let i = wasmEvalText(t, {"":{alloc: allocates, check3: check3}});
+
+print(i.exports.fn2( new Croissant(false, 31415927) ));
diff --git a/js/src/jit-test/tests/wasm/ref-types/stackmaps2.js b/js/src/jit-test/tests/wasm/ref-types/stackmaps2.js
new file mode 100644
index 0000000000..986d378a75
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/stackmaps2.js
@@ -0,0 +1,132 @@
+// Tests wasm frame tracing in the presence of interrupt handlers that perform
+// allocation.  The structure is
+//
+//   test top level: call fn2
+//   fn2: call fn1
+//   fn1: repeat { call-direct fn0; call-indirect fn0; }
+//   fn0: a 100-iteration loop that does nothing except waste time
+//
+// At the same time we are asynchronously runnning handler(), which does a lot
+// of allocation.  At some point that will trigger a GC.  Assuming that
+// handler() runs whilst fn0 is running (the most likely scenario, since fn0
+// consumes the majority of the wasm running time), then the runtime will walk
+// the stack from the wasm exit frame, through fn0, fn1 and finally fn2.  As
+// with stackmaps1.js, there are some ref-typed args in use so as provide
+// traceable stack slots to follow.
+//
+// The test runs until the loop in fn1 determines that handler() has allocated
+// sufficient memory as to have caused at least three collections.  This helps
+// keep the test effective in the face of wide variations in the rate of
+// progress of the handler()'s loop (eg x86+native is fast, arm64+simulator is
+// slow).
+
+const {Module,Instance} = WebAssembly;
+
+const DEBUG = false;
+
+let t =
+  `(module
+     (type $typeOfFn0
+           (func (param i32) (param externref) (param i32)
+                 (param externref) (param externref) (param i32) (result i32)))
+
+     (import "" "alloc" (func $alloc (result externref)))
+     (import "" "quitp" (func $quitp (result i32)))
+     (import "" "check3" (func $check3 (param externref) (param externref) (param externref)))
+
+     (table 1 1 funcref)
+     (elem (i32.const 0) $fn0)
+
+     ;; -- fn 0
+     (func $fn0 (export "fn0")
+                 (param $arg1 i32) (param $arg2 externref) (param $arg3 i32)
+                 (param $arg4 externref) (param $arg5 externref) (param $arg6 i32) (result i32)
+       (local $i i32)
+
+       ;; spinloop to waste time
+       (loop
+         (local.set $i (i32.add (local.get $i) (i32.const 1)))
+         (br_if 0 (i32.lt_s (local.get $i) (i32.const 100)))
+       )
+
+       (i32.add (i32.add (local.get $arg1) (local.get $arg3)) (local.get $arg6))
+
+       ;; Poke the ref-typed arguments, to be sure that they got kept alive
+       ;; properly across any GC that might have happened.
+       (call $check3 (local.get $arg2) (local.get $arg4) (local.get $arg5))
+     )
+
+     ;; -- fn 1
+     (func $fn1 (export "fn1") (param $arg1 externref) (result i32)
+       (loop (result i32)
+         ;; call direct to $fn0
+         (call $fn0 (i32.const 10) (local.get $arg1) (i32.const 12)
+                    (local.get $arg1) (local.get $arg1) (i32.const 15))
+
+         ;; call indirect to table index 0, which is $fn0
+         (call_indirect (type $typeOfFn0)
+                    (i32.const 10) (local.get $arg1) (i32.const 12)
+                    (local.get $arg1) (local.get $arg1) (i32.const 15)
+                    (i32.const 0)) ;; table index
+
+         i32.add
+
+         ;; Continue iterating until handler() has allocated enough
+         (br_if 0 (i32.eq (call $quitp) (i32.const 0)))
+       )
+     )
+
+     ;; -- fn 2
+     (func $fn2 (export "fn2") (param $arg1 externref) (result i32)
+       (call $fn1 (local.get $arg1))
+     )
+   )`;
+
+function Croissant(chocolate, number) {
+    this.chocolate = chocolate;
+    this.number = number;
+}
+
+function allocates() {
+    return new Croissant(true, 271828);
+}
+
+let totAllocs = 0;
+
+function handler() {
+    if (DEBUG) {
+        print('XXXXXXXX icallback: START');
+    }
+    let q = allocates();
+    let sum = 0;
+    let iters = 15000;
+    for (let i = 0; i < iters; i++) {
+        let x = allocates();
+        // Without this hoop jumping to create an apparent use of |x|, Ion
+        // will remove the allocation call and make the test pointless.
+        if (x == q) { sum++; }
+    }
+    totAllocs += iters;
+    // Artificial use of |sum|.  See comment above.
+    if (sum == 133713371337) { print("unlikely!"); }
+    timeout(0.5, handler);
+    if (DEBUG) {
+        print('XXXXXXXX icallback: END');
+    }
+    return true;
+}
+
+function quitp() {
+    return totAllocs > 200000 ? 1 : 0;
+}
+
+function check3(a1, a2, a3) {
+    assertEq(a1.number, 31415927);
+    assertEq(a2.number, 31415927);
+    assertEq(a3.number, 31415927);
+}
+
+let i = wasmEvalText(t, {"":{alloc: allocates, quitp: quitp, check3: check3}});
+
+timeout(0.5, handler);
+print(i.exports.fn2( new Croissant(false, 31415927) ));
diff --git a/js/src/jit-test/tests/wasm/ref-types/stackmaps3.js b/js/src/jit-test/tests/wasm/ref-types/stackmaps3.js
new file mode 100644
index 0000000000..1b4c15abd2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/stackmaps3.js
@@ -0,0 +1,201 @@
+// Generates a bunch of numbers-on-the-heap, and tries to ensure that they are
+// held live -- at least for a short while -- only by references from the wasm
+// evaluation stack.  Then assembles them in a list and checks that the list
+// is as expected (and we don't segfault).  While all this is running we also
+// have an regular interrupt whose handler does a bunch of allocation, so as
+// to cause as much disruption as possible.
+
+// Note this makes an assumption about how the wasm compiler works.  There's
+// no particular reason that the wasm compiler needs to keep the results of
+// the $mkBoxedInt calls on the machine stack.  It could equally cache them in
+// registers or even reorder the call sequences so as to interleave
+// construction of the list elements with construction of the list itself.  It
+// just happens that our baseline compiler will behave as described.  That
+// said, however, it's hard to imagine how an implementation could complete
+// the list construction without having at least one root in a register or on
+// the stack, so the test still has value regardless of how the underlying
+// implementation works.
+
+const {Module,Instance} = WebAssembly;
+
+const DEBUG = false;
+
+let t =
+  `(module
+     (import "" "mkCons" (func $mkCons (param externref) (param externref) (result externref)))
+     (import "" "mkBoxedInt" (func $mkBoxedInt (result externref)))
+
+     (func $mkNil (result externref)
+       ref.null extern
+     )
+
+     (func $mkConsIgnoringScalar
+              (param $hd externref) (param i32) (param $tl externref)
+              (result externref)
+        (local.get $hd)
+        (local.get $tl)
+        call $mkCons
+     )
+
+     (func $mkList (export "mkList") (result externref)
+        call $mkList20
+     )
+
+     (func $mkList20 (result externref)
+       ;; create 20 pointers to boxed ints on the stack, plus a few
+       ;; scalars for added confusion
+       (local $scalar99 i32)
+       (local $scalar97 i32)
+       (local.set $scalar99 (i32.const 99))
+       (local.set $scalar97 (i32.const 97))
+
+       call $mkBoxedInt
+       local.get $scalar99
+       call $mkBoxedInt
+       call $mkBoxedInt
+       local.get $scalar97
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkBoxedInt
+       call $mkNil
+       ;; Now we have (pointers to) 20 boxed ints and a NIL on the stack, and
+       ;; nothing else holding them live.  Build a list from the elements.
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkCons
+       call $mkConsIgnoringScalar
+       call $mkCons
+       call $mkConsIgnoringScalar
+     )
+   )`;
+
+let boxedIntCounter = 0;
+
+function BoxedInt() {
+    this.theInt = boxedIntCounter;
+    boxedIntCounter++;
+}
+
+function mkBoxedInt() {
+    return new BoxedInt();
+}
+
+function printBoxedInt(bi) {
+    print(bi.theInt);
+}
+
+function Cons(hd, tl) {
+    this.hd = hd;
+    this.tl = tl;
+}
+
+function mkCons(hd, tl) {
+    return new Cons(hd, tl);
+}
+
+function showList(list) {
+    print("[");
+    while (list) {
+        printBoxedInt(list.hd);
+        print(",");
+        list = list.tl;
+    }
+    print("]");
+}
+
+function checkList(list, expectedHdValue, expectedLength) {
+    while (list) {
+        if (expectedLength <= 0)
+            return false;
+        if (list.hd.theInt !== expectedHdValue) {
+            return false;
+        }
+        list = list.tl;
+        expectedHdValue++;
+        expectedLength--;
+    }
+    if (expectedLength == 0) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+let i = wasmEvalText(t, {"":{mkCons: mkCons, mkBoxedInt: mkBoxedInt}});
+
+
+function Croissant(chocolate) {
+    this.chocolate = chocolate;
+}
+
+function allocates() {
+    return new Croissant(true);
+}
+
+function handler() {
+    if (DEBUG) {
+        print('XXXXXXXX icallback: START');
+    }
+    let q = allocates();
+    let sum = 0;
+    for (let i = 0; i < 15000; i++) {
+        let x = allocates();
+        // Without this hoop jumping to create an apparent use of |x|, Ion
+        // will remove the allocation call and make the test pointless.
+        if (x == q) { sum++; }
+    }
+    // Artificial use of |sum|.  See comment above.
+    if (sum == 133713371337) { print("unlikely!"); }
+    timeout(1, handler);
+    if (DEBUG) {
+        print('XXXXXXXX icallback: END');
+    }
+    return true;
+}
+
+timeout(1, handler);
+
+for (let n = 0; n < 10000; n++) {
+    let listLowest = boxedIntCounter;
+
+    // Create the list in wasm land, possibly inducing GC on the way
+    let aList = i.exports.mkList();
+
+    // Check it is as we expect
+    let ok = checkList(aList, listLowest, 20/*expected length*/);
+    if (!ok) {
+        print("Failed on list: ");
+        showList(aList);
+    }
+    assertEq(ok, true);
+}
+
+// If we get here, the test finished successfully.
diff --git a/js/src/jit-test/tests/wasm/ref-types/stackmaps4-params-n-locals.js b/js/src/jit-test/tests/wasm/ref-types/stackmaps4-params-n-locals.js
new file mode 100644
index 0000000000..2b95ea14a6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/stackmaps4-params-n-locals.js
@@ -0,0 +1,143 @@
+// A stress test for stackmap creation as it relates to params and locals.
+
+function Stuff(n) {
+    this.n = n;
+}
+function allocate(n) {
+    const res = new Stuff(n);
+    // The webassembly loop below will provide us with 254 as an arg after not
+    // very long.
+    if (n == 254) {
+        gc();
+    }
+    return res;
+}
+
+function visit(aStuff) {
+    return aStuff.n;
+}
+
+let bin = wasmTextToBinary(
+`
+(module
+  (import "" "allocate" (func $allocate (param i32) (result externref)))
+  (import "" "visit" (func $visit (param externref) (result i32)))
+
+  ;; A function with many params and locals, most of which are ref-typed.
+  ;; The purpose of having so many is to defeat any reasonable attempt at
+  ;; allocating them all in registers.  The asymmetrically-placed i32s are
+  ;; an attempt to expose any misalignment or inversion of the stack layout
+  ;; vs what the stackmap claims the layout to be.
+
+  (func $manyParamsAndLocals (export "manyParamsAndLocals")
+    (param $p1 externref) (param $p2 i32)    (param $p3 externref)
+    (param $p4 externref) (param $p5 externref) (param $p6 externref)
+    (param $p7 externref) (param $p8 externref) (param $p9 i32)
+    (result i32)
+    (local $l1 externref) (local $l2 externref) (local $l3 externref)
+    (local $l4 i32)    (local $l5 externref) (local $l6 i32)
+    (local $l7 externref) (local $l8 externref) (local $l9 externref)
+
+    (local $i i32)
+    (local $runningTotal i32)
+
+    ;; Bind some objects to l1 .. l9.  The JS harness will already
+    ;; have done the same for p1 .. p9.
+    (local.set $l1 (call $allocate (i32.const 1)))
+    (local.set $l2 (call $allocate (i32.const 3)))
+    (local.set $l3 (call $allocate (i32.const 5)))
+    (local.set $l4 (i32.const 7))
+    (local.set $l5 (call $allocate (i32.const 9)))
+    (local.set $l6 (i32.const 11))
+    (local.set $l7 (call $allocate (i32.const 13)))
+    (local.set $l8 (call $allocate (i32.const 15)))
+    (local.set $l9 (call $allocate (i32.const 17)))
+
+    ;; Now loop, allocating as we go, and forcing GC every 256 iterations.
+    ;; Also in each iteration, visit all the locals and params, in the hope
+    ;; of exposing any cases where they are not held live across GC.
+    (loop $CONT
+      ;; Allocate, and hold on to the resulting value, so that Ion can't
+      ;; delete the allocation.
+      (local.set $l9 (call $allocate (i32.and (local.get $i) (i32.const 255))))
+
+      ;; Visit all params and locals
+
+      local.get $runningTotal
+
+      (call $visit (local.get $p1))
+      i32.add
+      local.get $p2
+      i32.add
+      (call $visit (local.get $p3))
+      i32.add
+      (call $visit (local.get $p4))
+      i32.add
+      (call $visit (local.get $p5))
+      i32.add
+      (call $visit (local.get $p6))
+      i32.add
+      (call $visit (local.get $p7))
+      i32.add
+      (call $visit (local.get $p8))
+      i32.add
+      local.get $p9
+      i32.add
+
+      (call $visit (local.get $l1))
+      i32.add
+      (call $visit (local.get $l2))
+      i32.add
+      (call $visit (local.get $l3))
+      i32.add
+      local.get $l4
+      i32.add
+      (call $visit (local.get $l5))
+      i32.add
+      local.get $l6
+      i32.add
+      (call $visit (local.get $l7))
+      i32.add
+      (call $visit (local.get $l8))
+      i32.add
+      (call $visit (local.get $l9))
+      i32.add
+
+      local.set $runningTotal
+
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br_if $CONT (i32.lt_s (local.get $i) (i32.const 10000)))
+    ) ;; loop
+
+    local.get $runningTotal
+  ) ;; func
+)
+`);
+
+let mod = new WebAssembly.Module(bin);
+let ins = new WebAssembly.Instance(mod, {"":{allocate, visit}});
+
+let p1 = allocate(97);
+let p2 = 93;
+let p3 = allocate(91);
+let p4 = allocate(83);
+let p5 = allocate(79);
+let p6 = allocate(73);
+let p7 = allocate(71);
+let p8 = allocate(67);
+let p9 = 61;
+
+let res = ins.exports.manyParamsAndLocals(p1, p2, p3, p4, p5, p6, p7, p8, p9);
+
+// Check that GC didn't mess up p1 .. p9
+res += visit(p1);
+res += p2;
+res += visit(p3);
+res += visit(p4);
+res += visit(p5);
+res += visit(p6);
+res += visit(p7);
+res += visit(p8);
+res += p9;
+
+assertEq(res, 9063795);
diff --git a/js/src/jit-test/tests/wasm/ref-types/tables-api.js b/js/src/jit-test/tests/wasm/ref-types/tables-api.js
new file mode 100644
index 0000000000..a2ae3c45f0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/tables-api.js
@@ -0,0 +1,93 @@
+// Test changes to the WebAssembly.Table API by reference-types
+
+function assertTableFilled(table, length, element) {
+  assertEq(table.length, length);
+  for (let i = 0; i < length; i++) {
+    assertEq(table.get(i), element);
+  }
+}
+
+const tableLength = 10;
+
+// Test table constructor can accept a default value to fill elements to
+for (let value of WasmExternrefValues) {
+  let table = new WebAssembly.Table({'element': 'externref', initial: tableLength}, value);
+  assertTableFilled(table, tableLength, value);
+}
+for (let value of WasmFuncrefValues) {
+  let table = new WebAssembly.Table({'element': 'anyfunc', initial: tableLength}, value);
+  assertTableFilled(table, tableLength, value);
+}
+
+// Test not specifying default value in constructor yields 'undefined' for externref
+{
+  let table = new WebAssembly.Table({'element': 'externref', initial: tableLength});
+  assertTableFilled(table, tableLength, undefined);
+}
+
+// Test not specifying default value in constructor yields 'null' for funcref
+{
+  let table = new WebAssembly.Table({'element': 'anyfunc', initial: tableLength});
+  assertTableFilled(table, tableLength, null);
+}
+
+// Test omitting the value in table set defaults to undefined for externref and
+// null for funcref.
+{
+    let t = new WebAssembly.Table({element:"externref", initial: 1});
+    // Clear out initial value
+    t.set(0, '');
+    // Set with an omitted value
+    t.set(0);
+    // Assert the omitted value is undefined
+    assertEq(t.get(0), undefined);
+}
+{
+    let t = new WebAssembly.Table({element:"anyfunc", initial: 1});
+    // Clear out initial value
+    t.set(0, WasmFuncrefValues[0]);
+    // Set with an omitted value
+    t.set(0);
+    // Assert the omitted value is null
+    assertEq(t.get(0), null);
+}
+
+// Test table grow. There is an optional fill argument that defaults to
+// undefined with externref, and null with funcref.
+{
+    let t = new WebAssembly.Table({element:"externref", initial:0});
+    t.grow(1);
+    assertEq(t.get(t.length-1), undefined);
+    let prev = undefined;
+    for (let v of WasmExternrefValues) {
+        t.grow(2, v);
+        assertEq(t.get(t.length-3), prev);
+        assertEq(t.get(t.length-2), v);
+
+        assertEq(t.get(t.length-1), v);
+        prev = v;
+    }
+}
+
+{
+    let t = new WebAssembly.Table({element:"anyfunc", initial:0});
+    t.grow(1);
+    assertEq(t.get(t.length-1), null);
+    let prev = null;
+    for (let v of WasmFuncrefValues) {
+        t.grow(2, v);
+        assertEq(t.get(t.length-3), prev);
+        assertEq(t.get(t.length-2), v);
+
+        assertEq(t.get(t.length-1), v);
+        prev = v;
+    }
+}
+
+// If growing by zero elements there are no spurious writes
+{
+    let t = new WebAssembly.Table({element:"externref", initial:1});
+    t.set(0, 1337);
+    t.grow(0, 1789);
+    assertEq(t.get(0), 1337);
+}
diff --git a/js/src/jit-test/tests/wasm/ref-types/tables-fill.js b/js/src/jit-test/tests/wasm/ref-types/tables-fill.js
new file mode 100644
index 0000000000..b6b821f1d0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/tables-fill.js
@@ -0,0 +1,212 @@
+const N = 8;
+
+function testTableFill(tbl_type, val_type, obj) {
+  assertEq(obj.length, N);
+
+  let ins
+     = wasmEvalText(
+        `(module
+           (table 8 ${tbl_type})     ;; table 0
+           (table $t 10 ${tbl_type}) ;; table 1
+
+           ;; fill/get for table 0, referenced implicitly
+           (func (export "fill0") (param $i i32) (param $r ${val_type}) (param $n i32)
+             (table.fill (local.get $i) (local.get $r) (local.get $n))
+           )
+           (func (export "get0") (param $i i32) (result ${tbl_type})
+             (table.get (local.get $i))
+           )
+
+           ;; fill/get for table 1, referenced explicitly
+           (func (export "fill1") (param $i i32) (param $r ${val_type}) (param $n i32)
+             (table.fill $t (local.get $i) (local.get $r) (local.get $n))
+           )
+           (func (export "get1") (param $i i32) (result ${tbl_type})
+             (table.get $t (local.get $i))
+           )
+         )`);
+
+  // An initial test to ascertain that tables 0 and 1 are independent
+
+  // Fill in table 0, then check it.
+  assertEq(ins.exports.fill0(2, obj[6], 5), undefined)
+  assertEq(ins.exports.fill0(1, obj[7], 3), undefined);
+
+  function check_table0() {
+      assertEq(ins.exports.get0(0), null);
+      assertEq(ins.exports.get0(1), obj[7]);
+      assertEq(ins.exports.get0(2), obj[7]);
+      assertEq(ins.exports.get0(3), obj[7]);
+      assertEq(ins.exports.get0(4), obj[6]);
+      assertEq(ins.exports.get0(5), obj[6]);
+      assertEq(ins.exports.get0(6), obj[6]);
+      assertEq(ins.exports.get0(7), null);
+  }
+
+  // Check that table 0 has the expected content.
+  check_table0();
+
+  // Check that messing with table 0 above hasn't changed table 1.
+  for (let i = 0; i < 10; i++) {
+      assertEq(ins.exports.get1(i), null);
+  }
+
+  // Now a bunch of tests involving only table 1.
+
+  // Partly outside the table
+  assertErrorMessage(() => ins.exports.fill1(8, obj[5], 3),
+                     WebAssembly.RuntimeError, /index out of bounds/);
+
+  assertEq(ins.exports.get1(7), null);
+  assertEq(ins.exports.get1(8), null);
+  assertEq(ins.exports.get1(9), null);
+
+  // Within the table
+  assertEq(ins.exports.fill1(2, obj[0], 3), undefined);
+  assertEq(ins.exports.get1(1), null);
+  assertEq(ins.exports.get1(2), obj[0]);
+  assertEq(ins.exports.get1(3), obj[0]);
+  assertEq(ins.exports.get1(4), obj[0]);
+  assertEq(ins.exports.get1(5), null);
+
+  // Within the table
+  assertEq(ins.exports.fill1(4, obj[1], 2), undefined);
+  assertEq(ins.exports.get1(3), obj[0]);
+  assertEq(ins.exports.get1(4), obj[1]);
+  assertEq(ins.exports.get1(5), obj[1]);
+  assertEq(ins.exports.get1(6), null);
+
+  // Within the table
+  assertEq(ins.exports.fill1(4, obj[2], 0), undefined);
+  assertEq(ins.exports.get1(3), obj[0]);
+  assertEq(ins.exports.get1(4), obj[1]);
+  assertEq(ins.exports.get1(5), obj[1]);
+
+  // Within the table
+  assertEq(ins.exports.fill1(8, obj[3], 2), undefined);
+  assertEq(ins.exports.get1(7), null);
+  assertEq(ins.exports.get1(8), obj[3]);
+  assertEq(ins.exports.get1(9), obj[3]);
+
+  // Within the table
+  assertEq(ins.exports.fill1(9, null, 1), undefined);
+  assertEq(ins.exports.get1(8), obj[3]);
+  assertEq(ins.exports.get1(9), null);
+
+  // Within the table
+  assertEq(ins.exports.fill1(10, obj[4], 0), undefined);
+  assertEq(ins.exports.get1(9), null);
+
+  // Boundary tests on table 1: at the edge of the table.
+
+  // Length-zero fill1 at the edge of the table must succeed
+  assertEq(ins.exports.fill1(10, null, 0), undefined);
+
+  // Length-one fill1 at the edge of the table fails
+  assertErrorMessage(() => ins.exports.fill1(10, null, 1),
+                     WebAssembly.RuntimeError, /index out of bounds/);
+
+  // Length-more-than-one fill1 at the edge of the table fails
+  assertErrorMessage(() => ins.exports.fill1(10, null, 2),
+                     WebAssembly.RuntimeError, /index out of bounds/);
+
+
+  // Boundary tests on table 1: beyond the edge of the table:
+
+  // Length-zero fill1 beyond the edge of the table fails
+  assertErrorMessage(() => ins.exports.fill1(11, null, 0),
+                     WebAssembly.RuntimeError, /index out of bounds/);
+
+  // Length-one fill1 beyond the edge of the table fails
+  assertErrorMessage(() => ins.exports.fill1(11, null, 1),
+                     WebAssembly.RuntimeError, /index out of bounds/);
+
+  // Length-more-than-one fill1 beyond the edge of the table fails
+  assertErrorMessage(() => ins.exports.fill1(11, null, 2),
+                     WebAssembly.RuntimeError, /index out of bounds/);
+
+  // Following all the above tests on table 1, check table 0 hasn't changed.
+  check_table0();
+}
+
+var objs = [];
+for (var i = 0; i < N; i++)
+  objs[i] = {n:i};
+testTableFill('externref', 'externref', objs);
+
+var funcs = [];
+for (var i = 0; i < N; i++)
+  funcs[i] = wasmEvalText(`(module (func (export "x") (result i32) (i32.const ${i})))`).exports.x;
+testTableFill('funcref', 'funcref', funcs);
+
+
+// Type errors.  Required sig is: (i32, externref, i32) -> void
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $expected-3-args-got-0
+        (table.fill $t)
+     ))`),
+     WebAssembly.CompileError, /(popping value from empty stack)|(nothing on stack)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $expected-3-args-got-1
+        (table.fill $t (i32.const 0))
+     ))`),
+     WebAssembly.CompileError, /(popping value from empty stack)|(nothing on stack)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $expected-3-args-got-2
+        (table.fill $t (ref.null extern) (i32.const 0))
+     ))`),
+     WebAssembly.CompileError, /(popping value from empty stack)|(nothing on stack)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $argty-1-wrong
+        (table.fill $t (i32.const 0) (ref.null extern) (f64.const 0))
+     ))`),
+     WebAssembly.CompileError,
+     /(type mismatch: expression has type f64 but expected i32)|(type mismatch: expected i32, found f64)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $argty-2-wrong
+        (table.fill $t (i32.const 0) (f32.const 0) (i32.const 0))
+     ))`),
+     WebAssembly.CompileError,
+     /(type mismatch: expression has type f32 but expected externref)|(type mismatch: expected externref, found f32)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $argty-3-wrong
+        (table.fill $t (i64.const 0) (ref.null extern) (i32.const 0))
+     ))`),
+     WebAssembly.CompileError,
+     /(type mismatch: expression has type i64 but expected i32)|(type mismatch: expected i32, found i64)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t 10 externref)
+      (func $retty-wrong (result i32)
+        (table.fill $t (i32.const 0) (ref.null extern) (i32.const 0))
+     ))`),
+     WebAssembly.CompileError,
+     /(popping value from empty stack)|(nothing on stack)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+       (table 8 funcref)
+       (func (param $v externref)
+         (table.fill (i32.const 0) (local.get $v) (i32.const 0)))
+     )`),
+     WebAssembly.CompileError,
+     /(expression has type externref but expected funcref)|(type mismatch: expected funcref, found externref)/);
diff --git a/js/src/jit-test/tests/wasm/ref-types/tables-generalized.js b/js/src/jit-test/tests/wasm/ref-types/tables-generalized.js
new file mode 100644
index 0000000000..19e530baae
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/tables-generalized.js
@@ -0,0 +1,432 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// General table management in wasm
+
+// Wasm: Create table-of-externref
+
+new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 externref))`));
+
+// Wasm: Import table-of-externref
+// JS: create table-of-externref
+
+new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table (import "m" "t") 10 externref))`)),
+                         {m:{t: new WebAssembly.Table({element:"externref", initial:10})}});
+
+new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (import "m" "t" (table 10 externref)))`)),
+                         {m:{t: new WebAssembly.Table({element:"externref", initial:10})}});
+
+// Wasm: Export table-of-externref, initial values shall be null
+
+{
+    let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table (export "t") 10 externref))`)));
+    let t = ins.exports.t;
+    assertEq(t.length, 10);
+    for (let i=0; i < t.length; i++)
+        assertEq(t.get(0), null);
+}
+
+// JS: Exported table can be grown, and values are preserved
+
+{
+    let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table (export "t") 10 externref))`)));
+    let t = ins.exports.t;
+    let objs = [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}];
+    for (let i in objs)
+        t.set(i, objs[i]);
+    ins.exports.t.grow(10);
+    assertEq(ins.exports.t.length, 20);
+    for (let i in objs)
+        assertEq(t.get(i), objs[i]);
+}
+
+// Wasm: table.copy between tables of externref (currently source and destination
+// are both table zero)
+
+{
+    let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table (export "t") 10 externref)
+       (func (export "f")
+         (table.copy (i32.const 5) (i32.const 0) (i32.const 3))))`)));
+    let t = ins.exports.t;
+    let objs = [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}];
+    for (let i in objs)
+        t.set(i, objs[i]);
+    ins.exports.f();
+    assertEq(t.get(0), objs[0]);
+    assertEq(t.get(1), objs[1]);
+    assertEq(t.get(2), objs[2]);
+    assertEq(t.get(3), objs[3]);
+    assertEq(t.get(4), objs[4]);
+    assertEq(t.get(5), objs[0]);
+    assertEq(t.get(6), objs[1]);
+    assertEq(t.get(7), objs[2]);
+    assertEq(t.get(8), objs[8]);
+    assertEq(t.get(9), objs[9]);
+}
+
+// Wasm: table.copy from table(funcref) to table(externref) should not work
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+  `(module
+     (table (export "t") 10 externref)
+     (func $f1)
+     (func $f2)
+     (func $f3)
+     (func $f4)
+     (func $f5)
+     (table 5 funcref)
+     (elem (table 1) (i32.const 0) func $f1 $f2 $f3 $f4 $f5)
+     (func (export "f")
+       (table.copy 0 1 (i32.const 5) (i32.const 0) (i32.const 5))))`)),
+    WebAssembly.CompileError,
+    /(expression has type funcref but expected externref)|(type mismatch)/);
+
+// Wasm: table.copy from table(externref) to table(funcref) should not work
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 funcref)
+       (table 10 externref)
+       (func (export "f")
+         (table.copy 0 1 (i32.const 0) (i32.const 0) (i32.const 5))))`)),
+                   WebAssembly.CompileError,
+                   /(expression has type externref but expected funcref)|(type mismatch)/);
+
+// Wasm: Element segments of funcref can't target tables of externref
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (func $f1 (result i32) (i32.const 0))
+       (table (export "t") 10 externref)
+       (elem 0 (i32.const 0) funcref (ref.func $f1)))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+
+
+// Wasm: Element segments of externref can't target tables of funcref
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table (export "t") 10 funcref)
+       (elem 0 (i32.const 0) externref (ref.null extern)))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+
+// Wasm: table.init on table-of-externref is not allowed when the segment has
+// funcref.
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (func $f1 (result i32) (i32.const 0))
+       (table 10 externref)
+       (elem funcref (ref.func $f1))
+       (func
+         (table.init 0 (i32.const 0) (i32.const 0) (i32.const 0))))`)),
+                   WebAssembly.CompileError,
+                   /(expression has type funcref but expected externref)|(type mismatch)/);
+
+
+// Wasm: table.init on table-of-funcref is not allowed when the segment has
+// externref.
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 funcref)
+       (elem externref (ref.null extern))
+       (func
+         (table.init 0 (i32.const 0) (i32.const 0) (i32.const 0))))`)),
+                   WebAssembly.CompileError,
+                   /(expression has type externref but expected funcref)|(type mismatch)/);
+
+// Wasm: table types must match at link time
+
+assertErrorMessage(
+    () => new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (import "m" "t" (table 10 externref)))`)),
+                                   {m:{t: new WebAssembly.Table({element:"anyfunc", initial:10})}}),
+    WebAssembly.LinkError,
+    /imported table type mismatch/);
+
+// call_indirect cannot reference table-of-externref
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 externref)
+       (type $t (func (param i32) (result i32)))
+       (func (result i32)
+         (call_indirect (type $t) (i32.const 37))))`)),
+                   WebAssembly.CompileError,
+                   /(indirect calls must go through a table of 'funcref')|(indirect calls must go through a table of funcref)/);
+
+///////////////////////////////////////////////////////////////////////////
+//
+// additional js api tests
+
+{
+    let tbl = new WebAssembly.Table({element:"externref", initial:10});
+
+    // Initial value is undefined. This is different from when tables are
+    // created inside wasm.
+    assertEq(tbl.get(0), undefined);
+
+    // Identity preserving.
+    let x = {hi: 48};
+    tbl.set(0, x);
+    assertEq(tbl.get(0), x);
+    tbl.set(2, dummy);
+    assertEq(tbl.get(2), dummy);
+    tbl.set(2, null);
+    assertEq(tbl.get(2), null);
+
+    // Temporary semantics is to convert to object and leave as object; once we
+    // have a better wrapped externref this will change, we won't be able to
+    // observe the boxing.
+    tbl.set(1, 42);
+    let y = tbl.get(1);
+    assertEq(typeof y, "number");
+    assertEq(y, 42);
+}
+
+function dummy() { return 37 }
+
+///////////////////////////////////////////////////////////////////////////
+//
+// table.get and table.set
+
+const wasmFun = wasmEvalText(`(module (func (export "x")))`).exports.x;
+
+// table.get in bounds - returns right value type & value
+// table.get out of bounds - fails
+
+function testTableGet(type, x) {
+    let ins = wasmEvalText(
+        `(module
+           (table (export "t") 10 ${type})
+           (func (export "f") (param i32) (result ${type})
+              (table.get (local.get 0))))`);
+    ins.exports.t.set(0, x);
+    assertEq(ins.exports.f(0), x);
+    assertEq(ins.exports.f(1), null);
+    assertErrorMessage(() => ins.exports.f(10), WebAssembly.RuntimeError, /index out of bounds/);
+    assertErrorMessage(() => ins.exports.f(-5), WebAssembly.RuntimeError, /index out of bounds/);
+}
+testTableGet('externref', {});
+testTableGet('funcref', wasmFun);
+
+// table.get with non-i32 index - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 externref)
+       (func (export "f") (param f64) (result externref)
+         (table.get (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+
+// table.get when there are no tables - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (func (export "f") (param i32)
+         (drop (table.get (local.get 0)))))`)),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.get)|(table index out of bounds)/);
+
+// table.set in bounds with i32 x externref - works, no value generated
+// table.set with null - works
+// table.set out of bounds - fails
+
+function testTableSet(lhs_type, rhs_type, rhs_reftype, x) {
+    let ins = wasmEvalText(
+        `(module
+           (table (export "t") 10 ${lhs_type})
+           (func (export "set_ref") (param i32) (param ${rhs_type})
+             (table.set (local.get 0) (local.get 1)))
+           (func (export "set_null") (param i32)
+             (table.set (local.get 0) (ref.null ${rhs_reftype}))))`);
+    ins.exports.set_ref(3, x);
+    assertEq(ins.exports.t.get(3), x);
+    ins.exports.set_null(3);
+    assertEq(ins.exports.t.get(3), null);
+
+    assertErrorMessage(() => ins.exports.set_ref(10, x), WebAssembly.RuntimeError, /index out of bounds/);
+    assertErrorMessage(() => ins.exports.set_ref(-1, x), WebAssembly.RuntimeError, /index out of bounds/);
+}
+testTableSet('externref', 'externref', 'extern', {});
+testTableSet('funcref', 'funcref', 'func', wasmFun);
+
+// Wasm: table.set on table(funcref) with externref value should fail
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+        `(module
+           (table (export "t") 10 funcref)
+           (func (export "set_ref") (param i32) (param externref)
+             (table.set (local.get 0) (local.get 1))))`)),
+                   WebAssembly.CompileError,
+                   /(type mismatch: expression has type externref but expected funcref)|(type mismatch: expected funcref, found externref)/);
+
+// table.set with non-i32 index - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 externref)
+       (func (export "f") (param f64)
+         (table.set (local.get 0) (ref.null extern))))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+
+// table.set with non-ref value - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 externref)
+       (func (export "f") (param f64)
+         (table.set (i32.const 0) (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 funcref)
+       (func (export "f") (param f64)
+         (table.set (i32.const 0) (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+
+// table.set when there are no tables - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+      (func (export "f") (param externref)
+       (table.set (i32.const 0) (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.set)|(table index out of bounds)/);
+
+function testTableGrow(lhs_type, lhs_reftype, rhs_type, x) {
+  let ins = wasmEvalText(
+      `(module
+        (table (export "t") 10 20 ${lhs_type})
+        (func (export "grow") (param i32) (result i32)
+         (table.grow (ref.null ${lhs_reftype}) (local.get 0)))
+        (func (export "grow2") (param i32) (param ${rhs_type}) (result i32)
+         (table.grow (local.get 1) (local.get 0))))`);
+
+  // we can grow table of references
+  // table.grow with zero delta - always works even at maximum
+  // table.grow with delta - works and returns correct old value
+  // table.grow with delta at upper limit - fails
+  // table.grow with negative delta - fails
+  assertEq(ins.exports.grow(0), 10);
+  assertEq(ins.exports.t.length, 10);
+  assertEq(ins.exports.grow(1), 10);
+  assertEq(ins.exports.t.length, 11);
+  assertEq(ins.exports.t.get(10), null);
+  assertEq(ins.exports.grow2(9, x), 11);
+  assertEq(ins.exports.t.length, 20);
+  for (var i = 11; i < 20; i++)
+    assertEq(ins.exports.t.get(i), x);
+  assertEq(ins.exports.grow(0), 20);
+
+  // The JS API throws if it can't grow
+  assertErrorMessage(() => ins.exports.t.grow(1), RangeError, /failed to grow table/);
+  assertErrorMessage(() => ins.exports.t.grow(-1), TypeError, /bad [Tt]able grow delta/);
+
+  // The wasm API does not throw if it can't grow, but returns -1
+  assertEq(ins.exports.grow(1), -1);
+  assertEq(ins.exports.t.length, 20);
+  assertEq(ins.exports.grow(-1), -1);
+  assertEq(ins.exports.t.length, 20)
+}
+testTableGrow('externref', 'extern', 'externref', 42);
+testTableGrow('funcref', 'func', 'funcref', wasmFun);
+
+// Wasm: table.grow on table(funcref) with externref initializer should fail
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+      `(module
+        (table (export "t") 10 20 funcref)
+        (func (export "grow2") (param i32) (param externref) (result i32)
+         (table.grow (local.get 1) (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /(type mismatch: expression has type externref but expected funcref)|(type mismatch: expected funcref, found externref)/);
+
+// Special case for private tables without a maximum
+
+{
+    let ins = wasmEvalText(
+        `(module
+          (table 10 externref)
+          (func (export "grow") (param i32) (result i32)
+           (table.grow (ref.null extern) (local.get 0))))`);
+    assertEq(ins.exports.grow(0), 10);
+    assertEq(ins.exports.grow(1), 10);
+    assertEq(ins.exports.grow(9), 11);
+    assertEq(ins.exports.grow(0), 20);
+}
+
+// table.grow with non-i32 argument - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (table 10 externref)
+       (func (export "f") (param f64)
+        (table.grow (ref.null extern) (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /type mismatch/);
+
+// table.grow when there are no tables - fails validation
+
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (func (export "f") (param i32)
+        (table.grow (ref.null extern) (local.get 0))))`)),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.grow)|(table index out of bounds)/);
+
+// table.size on table of externref
+
+for (let visibility of ['', '(export "t")', '(import "m" "t")']) {
+    let exp = {m:{t: new WebAssembly.Table({element:"externref",
+                                            initial: 10,
+                                            maximum: 20})}};
+    let ins = wasmEvalText(
+        `(module
+          (table ${visibility} 10 20 externref)
+          (func (export "grow") (param i32) (result i32)
+           (table.grow (ref.null extern) (local.get 0)))
+          (func (export "size") (result i32)
+           (table.size)))`,
+        exp);
+    assertEq(ins.exports.grow(0), 10);
+    assertEq(ins.exports.size(), 10);
+    assertEq(ins.exports.grow(1), 10);
+    assertEq(ins.exports.size(), 11);
+    assertEq(ins.exports.grow(9), 11);
+    assertEq(ins.exports.size(), 20);
+    assertEq(ins.exports.grow(0), 20);
+    assertEq(ins.exports.size(), 20);
+}
+
+// table.size on table of funcref
+
+{
+    let ins = wasmEvalText(
+        `(module
+          (table (export "t") 2 funcref)
+          (func (export "f") (result i32)
+           (table.size)))`);
+    assertEq(ins.exports.f(), 2);
+    ins.exports.t.grow(1);
+    assertEq(ins.exports.f(), 3);
+}
diff --git a/js/src/jit-test/tests/wasm/ref-types/tables-multiple.js b/js/src/jit-test/tests/wasm/ref-types/tables-multiple.js
new file mode 100644
index 0000000000..ca93824170
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/tables-multiple.js
@@ -0,0 +1,465 @@
+// Note that negative tests not having to do with table indices have been taken
+// care of by tables-generalized.js.
+
+///////////////////////////////////////////////////////////////////////////
+//
+// Positive tests
+
+// - multiple local tables of misc type: syntax, validation, instantiation
+// - element segments can point to a table
+// - call-indirect can specify a table and will use it
+
+var ins = wasmEvalText(
+    `(module
+      (table $t1 2 funcref)
+      (table $t2 2 funcref)
+      (type $ftype (func (param i32) (result i32)))
+      (elem (table $t1) (i32.const 0) func $f1 $f2)
+      (elem (table $t2) (i32.const 0) func $f3 $f4)
+      (func $f1 (param $n i32) (result i32)
+       (i32.add (local.get $n) (i32.const 1)))
+      (func $f2 (param $n i32) (result i32)
+       (i32.add (local.get $n) (i32.const 2)))
+      (func $f3 (param $n i32) (result i32)
+       (i32.add (local.get $n) (i32.const 3)))
+      (func $f4 (param $n i32) (result i32)
+       (i32.add (local.get $n) (i32.const 4)))
+      (func (export "f") (param $fn i32) (param $n i32) (result i32)
+       (call_indirect $t1 (type $ftype) (local.get $n) (local.get $fn)))
+      (func (export "g") (param $fn i32) (param $n i32) (result i32)
+       (call_indirect $t2 (type $ftype) (local.get $n) (local.get $fn))))`).exports;
+
+assertEq(ins.f(0, 10), 11);
+assertEq(ins.f(1, 10), 12);
+assertEq(ins.g(0, 10), 13);
+assertEq(ins.g(1, 10), 14);
+
+// - export multiple tables.
+//   note the first and third tables make the export list not start at zero,
+//   and make it sparse
+
+var ins = wasmEvalText(
+    `(module
+      (table $t0 (import "m" "t") 2 funcref)
+      (table $t1 (export "t1") 2 funcref)
+      (table 1 externref)
+      (table $t2 (export "t2") 3 funcref))`,
+    {m:{t: new WebAssembly.Table({element:"anyfunc", initial:2})}}).exports;
+
+assertEq(ins.t1 instanceof WebAssembly.Table, true);
+assertEq(ins.t1.length, 2);
+assertEq(ins.t2 instanceof WebAssembly.Table, true);
+assertEq(ins.t2.length, 3);
+
+// - multiple imported tables of misc type
+// - table.get and table.set can point to a table
+
+var exp = {m:{t0: new WebAssembly.Table({element:"anyfunc", initial:2}),
+              t1: new WebAssembly.Table({element:"externref", initial:3}),
+              t2: new WebAssembly.Table({element:"anyfunc", initial:4}),
+              t3: new WebAssembly.Table({element:"externref", initial:5})}};
+var ins = wasmEvalText(
+    `(module
+      (table $t0 (import "m" "t0") 2 funcref)
+      (table $t1 (import "m" "t1") 3 externref)
+      (table $t2 (import "m" "t2") 4 funcref)
+      (table $t3 (import "m" "t3") 5 externref)
+
+      (type $id_i32_t (func (param i32) (result i32)))
+      (func $id_i32 (param i32) (result i32) (local.get 0))
+      (elem (table $t0) (i32.const 1) func $id_i32)
+
+      (type $id_f64_t (func (param f64) (result f64)))
+      (func $id_f64 (param f64) (result f64) (local.get 0))
+      (elem (table $t2) (i32.const 3) func $id_f64)
+
+      (func (export "f0") (param i32) (result i32)
+       (call_indirect $t0 (type $id_i32_t) (local.get 0) (i32.const 1)))
+
+      (func (export "f1") (param externref)
+       (table.set $t1 (i32.const 2) (local.get 0)))
+
+      (func (export "f2") (param f64) (result f64)
+       (call_indirect $t2 (type $id_f64_t) (local.get 0) (i32.const 3)))
+
+      (func (export "f3")
+       (table.set $t3 (i32.const 4) (table.get $t1 (i32.const 2)))))`,
+
+    exp).exports;
+
+assertEq(ins.f0(37), 37);
+
+var x = {}
+ins.f1(x);
+assertEq(exp.m.t1.get(2), x);
+
+assertEq(ins.f2(3.25), 3.25);
+
+ins.f3();
+assertEq(exp.m.t3.get(4), x);
+
+// - table.grow can point to a table
+// - growing a table grows the right table but not the others
+// - table.size on tables other than table 0
+
+var exp = {m:{t0: new WebAssembly.Table({element:"externref", initial:2}),
+              t1: new WebAssembly.Table({element:"externref", initial:3})}};
+var ins = wasmEvalText(
+    `(module
+      (table $t0 (import "m" "t0") 2 externref)
+      (table $t1 (import "m" "t1") 3 externref)
+      (func (export "f") (result i32)
+       (table.grow $t1 (ref.null extern) (i32.const 5)))
+      (func (export "size0") (result i32)
+       (table.size $t0))
+      (func (export "size1") (result i32)
+       (table.size $t1)))`,
+    exp);
+
+assertEq(ins.exports.f(), 3);
+assertEq(exp.m.t1.length, 8);
+assertEq(ins.exports.size0(), 2);
+assertEq(ins.exports.size1(), 8);
+
+// - table.copy can point to tables
+
+var exp = {m:{t0: new WebAssembly.Table({element:"externref", initial:2}),
+              t1: new WebAssembly.Table({element:"externref", initial:3})}};
+var ins = wasmEvalText(
+    `(module
+      (table $t0 (import "m" "t0") 2 externref)
+      (table $t1 (import "m" "t1") 3 externref)
+      (func (export "f") (param $dest i32) (param $src i32) (param $len i32)
+       (table.copy $t1 $t0 (local.get $dest) (local.get $src) (local.get $len))))`,
+    exp);
+
+exp.m.t0.set(0, {x:0});
+exp.m.t0.set(1, {x:1});
+ins.exports.f(1, 0, 2);
+assertEq(exp.m.t1.get(1), exp.m.t0.get(0));
+assertEq(exp.m.t1.get(2), exp.m.t0.get(1));
+
+// - the table.copy syntax makes sense even in the non-parenthesized case
+
+var ins = wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func (export "copy") (param $dest i32) (param $src i32) (param $len i32)
+       local.get $dest
+       local.get $src
+       local.get $len
+       table.copy $t1 $t0)
+      (func (export "set") (param $n i32) (param $v externref)
+       (table.set $t0 (local.get $n) (local.get $v)))
+      (func (export "get") (param $n i32) (result externref)
+       (table.get $t1 (local.get $n))))`,
+    exp);
+
+var values = [{x:0}, {x:1}];
+ins.exports.set(0, values[0]);
+ins.exports.set(1, values[1]);
+ins.exports.copy(0, 0, 2);
+assertEq(ins.exports.get(0), values[0]);
+assertEq(ins.exports.get(1), values[1]);
+
+// Copy beween an external table and a local table.  These cases are interesting
+// mostly because the representations of the tables must be compatible; the copy
+// in effect forces a representation for the function in the local table that
+// captures the function's instance, at the latest at the time the copy is
+// executed.
+//
+// In the case where the function is imported, it comes from a different module.
+//
+// Also tests:
+// - local tables can be exported and re-imported in another module
+
+var arg = 4;
+for (let [a,b,x,y,result,init] of [['$t0', '$t1', '(export "t")', '', arg*13, true],
+                               ['$t0', '$t1', '', '(export "t")', arg*13, true],
+                               ['$t0', '$t1', '(import "m" "t")', '', arg*13, true],
+                               ['$t1', '$t0', '(import "m" "t")', '', arg-11, false]])
+{
+    var otherins = wasmEvalText(
+        `(module
+          (table $t (export "t") 2 funcref)
+          (type $fn1 (func (param i32) (result i32)))
+          (func $f1 (param $n i32) (result i32)
+           (i32.sub (local.get $n) (i32.const 11)))
+          (elem (table $t) (i32.const 1) func $f1))`);
+
+    let text =
+        `(module
+          (table ${a} ${x} 2 funcref)
+
+          (table ${b} ${y} 2 funcref)
+          (type $fn1 (func (param i32) (result i32)))
+          (func $f1 (param $n i32) (result i32)
+           (i32.mul (local.get $n) (i32.const 13)))
+          ${init ? "(elem (table $t1) (i32.const 1) func $f1)" : ""}
+
+          (func (export "f") (param $n i32) (result i32)
+           (table.copy $t0 $t1 (i32.const 0) (i32.const 0) (i32.const 2))
+           (call_indirect $t0 (type $fn1) (local.get $n) (i32.const 1))))`;
+    var ins = wasmEvalText(text, {m: otherins.exports});
+
+    assertEq(ins.exports.f(arg), result);
+}
+
+// - a table can be imported multiple times, and when it is, and one of them is grown,
+//   they are all grown.
+// - test the (import "m" "t" (table ...)) syntax
+// - if table is grown from JS, wasm can observe the growth
+
+var tbl = new WebAssembly.Table({element:"externref", initial:1});
+var exp = {m: {t0: tbl, t1:tbl}};
+
+var ins = wasmEvalText(
+    `(module
+      (import "m" "t0" (table $t0 1 externref))
+      (import "m" "t1" (table $t1 1 externref))
+      (table $t2 (export "t2") 1 funcref)
+      (func (export "f") (result i32)
+       (table.grow $t0 (ref.null extern) (i32.const 1)))
+      (func (export "g") (result i32)
+       (table.grow $t1 (ref.null extern) (i32.const 1)))
+      (func (export "size") (result i32)
+       (table.size $t2)))`,
+    exp);
+
+assertEq(ins.exports.f(), 1);
+assertEq(ins.exports.g(), 2);
+assertEq(ins.exports.f(), 3);
+assertEq(ins.exports.g(), 4);
+assertEq(tbl.length, 5);
+ins.exports.t2.grow(3);
+assertEq(ins.exports.size(), 4);
+
+// - table.init on tables other than table 0
+
+var ins = wasmEvalText(
+    `(module
+      (table $t0 2 funcref)
+      (table $t1 2 funcref)
+      (elem func $f0 $f1) ;; 0
+      (type $ftype (func (param i32) (result i32)))
+      (func $f0 (param i32) (result i32)
+       (i32.mul (local.get 0) (i32.const 13)))
+      (func $f1 (param i32) (result i32)
+       (i32.sub (local.get 0) (i32.const 11)))
+      (func (export "call") (param i32) (param i32) (result i32)
+       (call_indirect $t1 (type $ftype) (local.get 1) (local.get 0)))
+      (func (export "init")
+       (table.init $t1 0 (i32.const 0) (i32.const 0) (i32.const 2))))`);
+
+ins.exports.init();
+assertEq(ins.exports.call(0, 10), 130);
+assertEq(ins.exports.call(1, 10), -1);
+
+// - [white-box] if a multi-imported table of funcref is grown and the grown
+//   part is properly initialized with functions then calls through both tables
+//   in the grown area should succeed, ie, bounds checks should pass.  this is
+//   an interesting case because we cache the table bounds for the benefit of
+//   call_indirect, so here we're testing that the caches are updated properly
+//   even when a table is observed multiple times (also by multiple modules).
+//   there's some extra hair here because a table of funcref can be grown only
+//   from JS at the moment.
+// - also test that bounds checking continues to catch OOB calls
+
+var tbl = new WebAssembly.Table({element:"anyfunc", initial:2});
+var exp = {m:{t0: tbl, t1: tbl}};
+var ins = wasmEvalText(
+    `(module
+      (import "m" "t0" (table $t0 2 funcref))
+      (import "m" "t1" (table $t1 2 funcref))
+      (type $ftype (func (param f64) (result f64)))
+      (func (export "f") (param $n f64) (result f64)
+       (f64.mul (local.get $n) (f64.const 3.25)))
+      (func (export "do0") (param $i i32) (param $n f64) (result f64)
+       (call_indirect $t0 (type $ftype) (local.get $n) (local.get $i)))
+      (func (export "do1") (param $i i32) (param $n f64) (result f64)
+       (call_indirect $t1 (type $ftype) (local.get $n) (local.get $i))))`,
+    exp);
+var ins2 = wasmEvalText(
+    `(module
+      (import "m" "t0" (table $t0 2 funcref))
+      (import "m" "t1" (table $t1 2 funcref))
+      (type $ftype (func (param f64) (result f64)))
+      (func (export "do0") (param $i i32) (param $n f64) (result f64)
+       (call_indirect $t0 (type $ftype) (local.get $n) (local.get $i)))
+      (func (export "do1") (param $i i32) (param $n f64) (result f64)
+       (call_indirect $t1 (type $ftype) (local.get $n) (local.get $i))))`,
+    exp);
+
+assertEq(tbl.grow(10), 2);
+tbl.set(11, ins.exports.f);
+assertEq(ins.exports.do0(11, 2.0), 6.5);
+assertEq(ins.exports.do1(11, 4.0), 13.0);
+assertEq(ins2.exports.do0(11, 2.0), 6.5);
+assertEq(ins2.exports.do1(11, 4.0), 13.0);
+assertErrorMessage(() => ins.exports.do0(12, 2.0),
+                   WebAssembly.RuntimeError,
+                   /index out of bounds/);
+assertErrorMessage(() => ins2.exports.do0(12, 2.0),
+                   WebAssembly.RuntimeError,
+                   /index out of bounds/);
+assertErrorMessage(() => ins.exports.do1(12, 2.0),
+                   WebAssembly.RuntimeError,
+                   /index out of bounds/);
+assertErrorMessage(() => ins2.exports.do1(12, 2.0),
+                   WebAssembly.RuntimeError,
+                   /index out of bounds/);
+
+///////////////////////////////////////////////////////////////////////////
+//
+// Negative tests
+
+// Table index (statically) out of bounds
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func $f (result externref)
+       (table.get 2 (i32.const 0))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.get)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func $f (param externref)
+       (table.set 2 (i32.const 0) (local.get 0))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.set)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func $f (param externref)
+       (table.copy 0 2 (i32.const 0) (i32.const 0) (i32.const 2))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.copy)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func $f (param externref)
+       (table.copy 2 0 (i32.const 0) (i32.const 0) (i32.const 2))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.copy)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func $f (result i32)
+       (table.size 2)))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.size)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 externref)
+      (table $t1 2 externref)
+      (func $f (result i32)
+       (table.grow 2 (ref.null extern) (i32.const 1))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.grow)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 funcref)
+      (elem func) ;; 0
+      (func $f (result i32)
+       (table.init 2 0 (i32.const 0) (i32.const 0) (i32.const 0))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for table.init)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 funcref)
+      (elem 2 (i32.const 0) func))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for element segment)|(table index out of bounds)/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 funcref)
+      (type $ft (func (param f64) (result i32)))
+      (func $f (result i32)
+       (call_indirect 2 (type $ft) (f64.const 3.14) (i32.const 0))))`),
+                   WebAssembly.CompileError,
+                   /(table index out of range for call_indirect)|(table index out of bounds)/);
+
+// Syntax errors when parsing text
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 funcref)
+      (elem func) ;; 0
+      (func $f (result i32)
+       (table.init $t0 (i32.const 0) (i32.const 0) (i32.const 0))))`), // no segment
+                   SyntaxError,
+                   /failed to find name/);
+
+assertErrorMessage(() => wasmEvalText(
+    `(module
+      (table $t0 2 funcref)
+      (table $t1 2 funcref)
+      (func $f
+       (table.copy 0 (i32.const 0) (i32.const 0) (i32.const 2))))`), // target without source
+                   SyntaxError,
+                   /unexpected token, expected an identifier or u32/);
+
+// Make sure that dead code doesn't prevent compilation.
+wasmEvalText(
+    `(module
+       (table (export "t") 10 externref)
+       (func (param i32)
+         (return)
+         (table.get (get_local 0))
+         (drop)
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (table (export "t") 10 externref)
+       (func (param i32) (param i32)
+         (return)
+         (table.grow (get_local 1))
+         (drop)
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (table (export "t") 10 externref)
+       (func (param i32) (param externref)
+         (return)
+         (table.set (get_local 0) (get_local 1))
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (table (export "t") 10 externref)
+       (func
+         (return)
+         (table.size)
+         (drop)
+        )
+    )`);
+
+wasmEvalText(
+    `(module
+       (table (export "t") 10 externref)
+       (func
+         (return)
+         (table.copy (i32.const 0) (i32.const 1))
+        )
+    )`);
diff --git a/js/src/jit-test/tests/wasm/ref-types/tables-postbarrier-grow.js b/js/src/jit-test/tests/wasm/ref-types/tables-postbarrier-grow.js
new file mode 100644
index 0000000000..20086e6579
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/tables-postbarrier-grow.js
@@ -0,0 +1,21 @@
+// Add test for issue with a post-write barrier that doesn't remove
+// store buffer entries when used on a table that may grow.
+
+let {set, table} = wasmEvalText(`(module
+	(table (export "table") 1 externref)
+	(func (export "set") (param externref)
+		i32.const 0
+		local.get 0
+		table.set
+	)
+)`).exports;
+
+let tenured = {};
+gc(tenured);
+assertEq(isNurseryAllocated(tenured), false);
+let nursery = {};
+assertEq(isNurseryAllocated(nursery), true);
+set(nursery);
+set(null);
+assertEq(table.grow(1000), 1, 'table grows');
+gc();
diff --git a/js/src/jit-test/tests/wasm/ref-types/tables-stress.js b/js/src/jit-test/tests/wasm/ref-types/tables-stress.js
new file mode 100644
index 0000000000..2e13e76ba0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/ref-types/tables-stress.js
@@ -0,0 +1,46 @@
+for ( let prefix of ['', '(table $prefix 0 32 funcref)']) {
+    let mod = new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (import "m" "item" (func $item (result externref)))
+       ${prefix}
+       (table $tbl 0 externref)
+       (func (export "run") (param $numiters i32)
+         (local $i i32)
+         (local $j i32)
+         (local $last i32)
+         (local $iters i32)
+         (local $tmp externref)
+         (local.set $last (table.grow $tbl (ref.null extern) (i32.const 1)))
+         (table.set $tbl (local.get $last) (call $item))
+         (loop $iter_continue
+           (local.set $i (i32.const 0))
+           (local.set $j (local.get $last))
+           (block $l_break
+             (loop $l_continue
+               (br_if $l_break (i32.ge_s (local.get $j) (local.get $i)))
+               (local.set $tmp (table.get $tbl (local.get $i)))
+               (if (i32.eqz (i32.rem_s (local.get $i) (i32.const 3)))
+                   (local.set $tmp (call $item)))
+               (table.set $tbl (local.get $i) (table.get $tbl (local.get $j)))
+               (table.set $tbl (local.get $j) (local.get $tmp))
+               (local.set $i (i32.add (local.get $i) (i32.const 1)))
+               (local.set $j (i32.sub (local.get $j) (i32.const 1)))
+               (br $l_continue))
+           (local.set $iters (i32.add (local.get $iters) (i32.const 1)))
+           (br_if $iter_continue (i32.lt_s (local.get $iters) (local.get $numiters)))))))`));
+
+    for (let [mode,freq] of [[14,100],  // Compact every 100 allocations
+                             [2,12],    // Collect every 12 allocations
+                             [7,100],   // Minor gc every 100 allocations
+                             [15,100]]) // Verify heap integrity
+    {
+        if (this.gczeal)
+            this.gczeal(mode,freq);
+        let k = 0;
+        let ins = new WebAssembly.Instance(mod, {m:{item:() => { return { x: k++ } }}}).exports;
+        for ( let i=0; i < 1000; i++ )
+            ins.run(1000);
+    }
+}
+
+
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-arm64-chunk-pop.js b/js/src/jit-test/tests/wasm/regress/baseline-arm64-chunk-pop.js
new file mode 100644
index 0000000000..23aa5934a4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-arm64-chunk-pop.js
@@ -0,0 +1,31 @@
+var bin = wasmTextToBinary(
+    `(module
+       (func (export "f4786") (result i32)
+         (local i32 i64 i64 i64 f32)
+         i32.const 1
+         tee_local 0
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         local.get 0
+         if (result i32)
+           local.get 0
+         else
+           local.get 0
+           tee_local 0
+           local.get 0
+           br_if 1
+         end
+         drop
+         drop
+         drop
+         drop
+         drop
+         drop
+         drop))`);
+var ins = new WebAssembly.Instance(new WebAssembly.Module(bin));
+ins.exports.f4786();
+
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-builtin-abi.js b/js/src/jit-test/tests/wasm/regress/baseline-builtin-abi.js
new file mode 100644
index 0000000000..16de2dc400
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-builtin-abi.js
@@ -0,0 +1,20 @@
+// Bug 1488515 - ABI issues on Android because both the baseline compiler and
+// the builtin thunks converted between hardFP and softFP.
+
+var prog = wasmEvalText(
+    `(module
+       (func $f64div (export "test") (param $a f64) (param $b f64) (result f64)
+         (local $dummy0 i32)
+         (local $dummy1 i32)
+         (local $dummy2 i32)
+         (local $dummy3 i32)
+         (local $dummy4 i32)
+         (local $x f64)
+         (local $y f64)
+         (local $z f64)
+         (local.set $x (local.get $a))
+         (local.set $y (local.get $b))
+         (local.set $z (f64.floor (f64.div (local.get $x) (local.get $y))))
+         (local.get $z)))`);
+
+assertEq(prog.exports.test(16096, 32), 503);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-bytereg.js b/js/src/jit-test/tests/wasm/regress/baseline-bytereg.js
new file mode 100644
index 0000000000..8bdcc32618
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-bytereg.js
@@ -0,0 +1,34 @@
+// Bug 1322450 is about the baseline compiler not properly handling a byte store
+// from a wider datum on 32-bit x86 because it does not move the value to be
+// stored to a valid byte register if it is in a 32-bit register that does not
+// have a byte part (EDI/ESI/EBP).
+//
+// This test is white-box because it knows about the register allocation order:
+// the two values pushed onto the stack occupy EAX and ECX, and the i64.store8
+// will use EDX for the index and (EDI or ESI or EBP) for the low register of
+// the value to be stored.  The i64.store8 instruction will then assert in the
+// assembler.
+//
+// If the baseline compiler starts allocating registers in a different order
+// then this test will be ineffective.
+
+wasmEvalText(`(module
+    (memory 1)
+    (func $run (param i64) (param i32) (param i32)
+        local.get 1
+        local.get 2
+        i32.add
+
+        local.get 1
+        local.get 2
+        i32.add
+
+        i32.const 0
+        local.get 0
+        i64.store8
+
+        drop
+        drop
+    )
+    (export "run" (func $run))
+)`);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-extend8.js b/js/src/jit-test/tests/wasm/regress/baseline-extend8.js
new file mode 100644
index 0000000000..6e637e97c9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-extend8.js
@@ -0,0 +1,34 @@
+// This attempts to test that we can do an 8-bit sign extend no matter what the
+// source register.  This test is arguably somewhat tied to the baseline
+// compiler's register allocator, but is still appropriate for most simple
+// register allocators.  It works by filling an increasing number of registers
+// with values so as eventually to force the source operand for extend8_s into a
+// register that does not have a byte personality.
+
+for ( let i=0; i < 8; i++) {
+    let txt =
+        `(module
+           (func (export "f") (param i32) (result i32)
+           ${adds(i)}
+           (local.set 0 (i32.extend8_s (i32.add (local.get 0) (i32.const 1))))
+           ${drops(i)}
+           (local.get 0)))`;
+    let ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(txt)));
+    assertEq(ins.exports.f(254), -1);
+}
+
+function adds(n) {
+    let s = ""
+    for ( let i=0; i < n; i++ )
+        s += "(i32.add (local.get 0) (i32.const 1))\n";
+    return s;
+}
+
+function drops(n) {
+    let s = "";
+    for ( let i=0; i < n; i++ )
+        s += "drop\n";
+    return s;
+}
+
+
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-getglobal-scratch.js b/js/src/jit-test/tests/wasm/regress/baseline-getglobal-scratch.js
new file mode 100644
index 0000000000..2f4d74b912
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-getglobal-scratch.js
@@ -0,0 +1,58 @@
+new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (global $g (mut i32) (i32.const 42))
+    (func (param $i i32)
+        local.get $i
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        unreachable
+    )
+)
+`));
+
+new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (global $g (mut i32) (i32.const 42))
+    (func (param $i i32)
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        global.get $g
+        local.get $i
+        global.set $g
+        unreachable
+    )
+)
+`));
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-i64-opt-cmp.js b/js/src/jit-test/tests/wasm/regress/baseline-i64-opt-cmp.js
new file mode 100644
index 0000000000..eb6cafb8f0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-i64-opt-cmp.js
@@ -0,0 +1,16 @@
+// Bug 1404760: Optimized compare-and-branch with a preserved value would fail
+// the baseline compiler on x86 debug builds (and would just generate bad code
+// on non-debug builds) because of register starvation.
+
+wasmEvalText(
+    `(module
+      (func $run (param i64) (param i64) (result i64)
+        block (result i64)
+	  i64.const 1
+          (i64.lt_s (local.get 0) (local.get 1))
+	  br_if 0
+	  drop
+          i64.const 2
+        end)
+      (export "run" (func $run)))`
+);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-joinreg.js b/js/src/jit-test/tests/wasm/regress/baseline-joinreg.js
new file mode 100644
index 0000000000..01bc3d5bbc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-joinreg.js
@@ -0,0 +1,16 @@
+// Bug 1322288 is about the floating join register not being reserved properly
+// in the presence of boolean evaluation for control.  The situation is that a
+// conditional branch passes a floating point value to the join point; the join register
+// must be available when it does that, but could have been allocated to the operands of
+// the conditional expression of the control flow.
+//
+// This test is white-box: it depends on the floating join reg being among the first
+// floating registers to be allocated.
+
+wasmEvalText(`
+(module
+ (func $run
+  (drop (block (result f64)
+   (drop (br_if 0 (f64.const 1) (f64.eq (f64.const 1) (f64.const 0))))
+   (drop (br 0 (f64.const 2))))))
+ (export "run" (func $run)))`);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-many-results.js b/js/src/jit-test/tests/wasm/regress/baseline-many-results.js
new file mode 100644
index 0000000000..ff4d9c35dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-many-results.js
@@ -0,0 +1,63 @@
+// This provokes a crash in baseline if its Stk reservation logic is not up to
+// snuff, bug 1675844.
+
+var txt = `
+(module
+  (type (;0;) (func (result f32 f32 i32)))
+  (func $main (type 0) (result f32 f32 i32)
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    memory.size
+    call $main
+    call $main
+    call $main
+    call_indirect (type 0)
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    memory.size
+    call $main
+    call $main
+    call $main
+    call_indirect (type 0)
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    call $main
+    memory.size)
+  (table (;0;) 62 255 funcref)
+  (memory (;0;) 15 18)
+  (export "t1" (table 0))
+  (export "memory" (memory 0)))`;
+assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(txt)),
+                   WebAssembly.CompileError,
+                   /(unused values not explicitly dropped)|(expected f32, found i32)/);
+
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-nops-jumptable.js b/js/src/jit-test/tests/wasm/regress/baseline-nops-jumptable.js
new file mode 100644
index 0000000000..e4388296fb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-nops-jumptable.js
@@ -0,0 +1,12 @@
+// |jit-test| --arm-asm-nop-fill=1
+var f = wasmEvalText(`(module (func (param i32) (result i32)
+      (block $0
+       (block $1
+        (block $2
+         (block $default
+          (br_table $0 $1 $2 $default (local.get 0))))))
+      (return (i32.const 0)))
+    (export "" (func 0))
+)`).exports[""];
+
+f(0);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-pop-along-edge.js b/js/src/jit-test/tests/wasm/regress/baseline-pop-along-edge.js
new file mode 100644
index 0000000000..650931c99a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-pop-along-edge.js
@@ -0,0 +1,66 @@
+// Bug 1316181
+
+// There are locals with different values here to ensure that the
+// local.get at the end picks up the right one even if the stack might
+// have become unbalanced by a failure to adjust SP along the branch
+// edge.  The logic is that we use SP-relative addressing, and if the
+// actual SP is not what the compiler thinks it is we will read
+// something other than the expected value.
+
+var o = wasmEvalText(
+    `(module
+      (func (result i32)
+       (local $v0 i32)
+       (local $v1 i32)
+       (local $v2 i32)
+       (local $v3 i32)
+       (local $v4 i32)
+       (local $v5 i32)
+       (local $v6 i32)
+       (local $v7 i32)
+       (local $res i32)
+       (local.set $v0 (i32.const 0xDEADBEEF))
+       (local.set $v1 (i32.const 0xFDEADBEE))
+       (local.set $v2 (i32.const 0xEFDEADBE))
+       (local.set $v3 (i32.const 0xEEFDEADB))
+       (local.set $v4 (i32.const 0xBEEFDEAD))
+       (local.set $v5 (i32.const 0xDBEEFDEA))
+       (local.set $v6 (i32.const 0xADBEEFDE))
+       (local.set $v7 (i32.const 0xEADBEEFD))
+       (block $b
+	(local.set $res
+	 (i32.add
+	  (i32.add (i32.const 1) (i32.const 2))
+	  (i32.add
+	   (i32.add (i32.const 3) (i32.const 4))
+	   (i32.add
+	    (i32.add (i32.const 5) (i32.const 6))
+	    (i32.add
+	     (i32.add (i32.const 7) (i32.const 8))
+	     (i32.add
+	      (i32.add (i32.const 9) (i32.const 10))
+	      (i32.add
+	       (i32.add (i32.const 11) (i32.const 12))
+	       (i32.add
+		(i32.add (i32.const 13) (i32.const 14))
+		(i32.add
+		 (i32.add (i32.const 15) (i32.const 16))
+		 (i32.add
+		  (i32.add (i32.const 17) (i32.const 18))
+		  (i32.add
+		   (i32.add (i32.const 19) (i32.const 20))
+		   (i32.add
+		    (i32.add (i32.const 21) (i32.const 22))
+		    (i32.add
+		     (i32.add (i32.const 23) (i32.const 24))
+		     (i32.add
+		      (i32.add (i32.const 25) (i32.const 26))
+		      (i32.add
+		       (i32.add (i32.const 27) (i32.const 28))
+		       (i32.add
+			(i32.add (i32.const 29) (i32.const 30))
+			(br_if $b (i32.const 31) (i32.const 1)))))))))))))))))))
+       (return (local.get $v3)))
+      (export "a" (func 0)))`).exports;
+
+assertEq(o["a"](), 0xEEFDEADB|0);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-pop-before-capture.js b/js/src/jit-test/tests/wasm/regress/baseline-pop-before-capture.js
new file mode 100644
index 0000000000..b3a41f6949
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-pop-before-capture.js
@@ -0,0 +1,12 @@
+// Bug 1319415
+
+var src =
+`(module
+  (func (result i32)
+    i32.const 0
+    i32.const 1
+    br_if 0
+    unreachable)
+  (export "run" (func 0)))`;
+
+wasmFullPass(src, 0);
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-stack-height.js b/js/src/jit-test/tests/wasm/regress/baseline-stack-height.js
new file mode 100644
index 0000000000..185a7c3069
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-stack-height.js
@@ -0,0 +1 @@
+new WebAssembly.Module(os.file.readFile(scriptdir + "/baseline-stack-height.wasm", 'binary'));
diff --git a/js/src/jit-test/tests/wasm/regress/baseline-stack-height.wasm b/js/src/jit-test/tests/wasm/regress/baseline-stack-height.wasm
new file mode 100644
index 0000000000..cc25a1dac8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/baseline-stack-height.wasm
diff --git a/js/src/jit-test/tests/wasm/regress/brtable-conditionblock-folding.js b/js/src/jit-test/tests/wasm/regress/brtable-conditionblock-folding.js
new file mode 100644
index 0000000000..6692a7473b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/brtable-conditionblock-folding.js
@@ -0,0 +1,17 @@
+assertEq(wasmEvalText(`
+(module
+  (func $f (param $p i32)
+    block $out
+      i32.const 0
+      if
+        i32.const 1
+        tee_local $p
+        br_table $out $out
+      end
+    end
+    local.get $p
+    br_if 0
+  )
+  (export "f" (func $f))
+)
+`).exports.f(42), undefined);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1300546.js b/js/src/jit-test/tests/wasm/regress/bug1300546.js
new file mode 100644
index 0000000000..2897995deb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1300546.js
@@ -0,0 +1,28 @@
+try {
+    wasmEvalText(`
+    (module
+      (type $type0 (func))
+      (func $func0
+          (nop)
+          (f64.load offset=59 align=1 (i32.const 0))
+          (memory.size)
+          (memory.size)
+          (memory.size)
+          (memory.size)
+          (memory.size)
+          (memory.size)
+          (memory.size)
+          (memory.size)
+          (i64.rem_s (i64.const 17) (i64.xor (i64.const 17) (i64.xor (i64.const 17) (i64.xor (i64.xor (i64.const 17) (i64.const 17)) (i64.xor (i64.const 17) (i64.const 17))))))
+
+         (i64.rem_s
+          (i64.const 17)
+          (i64.xor
+            (i64.rem_s (i64.const 17) (i64.const 17))
+            (i64.xor (i64.rem_s (i64.const 17) (i64.const 17)) (i64.xor (i64.const 17) (i64.const 17)))))
+      )
+      (memory 1 1)
+    )
+    `);
+} catch(e) {
+}
diff --git a/js/src/jit-test/tests/wasm/regress/bug1311019.js b/js/src/jit-test/tests/wasm/regress/bug1311019.js
new file mode 100644
index 0000000000..3c5c39e352
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1311019.js
@@ -0,0 +1,9 @@
+new WebAssembly.Module(wasmTextToBinary(`(module
+    (memory 1)
+    (func
+        (i64.trunc_s/f32 (f32.const 6.96875))
+        (i32.load8_s (i32.const 0))
+        (f32.const -7.66028056e-31)
+        (unreachable)
+    )
+)`));
diff --git a/js/src/jit-test/tests/wasm/regress/bug1392105.js b/js/src/jit-test/tests/wasm/regress/bug1392105.js
new file mode 100644
index 0000000000..4752da8ddf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1392105.js
@@ -0,0 +1,8 @@
+// |jit-test| --arm-asm-nop-fill=1
+
+var code = "(module ";
+for (var i = 0; i < 100; i++)
+  code += "(func (param i32) (result i32) (i32.add (i32.const 1) (local.get 0))) ";
+code += ")";
+var buf = wasmTextToBinary(code);
+WebAssembly.compile(buf);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1440512.js b/js/src/jit-test/tests/wasm/regress/bug1440512.js
new file mode 100644
index 0000000000..1997b34f7f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1440512.js
@@ -0,0 +1,216 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+var g = newGlobal({newCompartment: true});
+var dbg = new g.Debugger(this);
+var dbg = new Debugger;
+var kWasmH0 = 0;
+var kWasmH1 = 0x61;
+var kWasmH2 = 0x73;
+var kWasmH3 = 0x6d;
+var kWasmV0 = 0x1;
+var kWasmV1 = 0;
+var kWasmV2 = 0;
+var kWasmV3 = 0;
+let kTypeSectionCode = 1; // Function signature declarations
+let kImportSectionCode = 2; // Import declarations
+let kFunctionSectionCode = 3; // Function declarations
+let kExportSectionCode = 7; // Exports
+let kCodeSectionCode = 10; // Function code
+let kWasmFunctionTypeForm = 0x60;
+let kWasmI32 = 0x7f;
+let kExternalFunction = 0;
+let kSig_i_i = makeSig([kWasmI32], [kWasmI32]);
+function makeSig(params, results) {
+    return {
+        params: params,
+        results: results
+    };
+}
+let kExprEnd = 0x0b;
+let kExprGetLocal = 0x20;
+class Binary extends Array {
+    emit_u8(val) {
+        this.push(val);
+    }
+    emit_u32v(val) {
+        while (true) {
+            let v = val & 0xff;
+            val = val >>> 7;
+                this.push(v);
+                break;
+        }
+    }
+    emit_bytes(data) {
+        for (let i = 0; i < data.length; i++) {
+            this.push(data[i] & 0xff);
+        }
+    }
+    emit_string(string) {
+        let string_utf8 = unescape(encodeURIComponent(string));
+        this.emit_u32v(string_utf8.length);
+        for (let i = 0; i < string_utf8.length; i++) {
+            this.emit_u8(string_utf8.charCodeAt(i));
+        }
+    }
+    emit_header() {
+        this.push(kWasmH0, kWasmH1, kWasmH2, kWasmH3, kWasmV0, kWasmV1, kWasmV2, kWasmV3);
+    }
+    emit_section(section_code, content_generator) {
+        this.emit_u8(section_code);
+        let section = new Binary;
+        content_generator(section);
+        this.emit_u32v(section.length);
+        for (var i = 0; i < section.length; i++) this.push(section[i]);
+    }
+}
+class WasmFunctionBuilder {
+    constructor(module, name, type_index) {
+        this.module = module;
+    }
+    exportAs(name) {
+        this.module.addExport(name, this.index);
+    }
+    addBody(body) {
+        this.body = body.slice();
+        this.body.push(kExprEnd);
+        return this;
+    }
+}
+class WasmModuleBuilder {
+    constructor() {
+        this.types = [];
+        this.imports = [];
+        this.exports = [];
+        this.functions = [];
+    }
+    addType(type) {
+        this.types.push(type);
+    }
+    addFunction(name, type) {
+        let type_index = (typeof type) == "number" ? type : this.addType(type);
+        let func = new WasmFunctionBuilder(this, name, type_index);
+        this.functions.push(func);
+        return func;
+    }
+    addImport(module = "", name, type) {
+        this.imports.push({
+            module: module,
+            name: name,
+            kind: kExternalFunction,
+        });
+    }
+    addExport(name, index) {
+        this.exports.push({
+            name: name,
+        });
+    }
+    toArray(debug = false) {
+        let binary = new Binary;
+        let wasm = this;
+        binary.emit_header();
+        if (wasm.types.length > 0) {
+            binary.emit_section(kTypeSectionCode, section => {
+                section.emit_u32v(wasm.types.length);
+                for (let type of wasm.types) {
+                    section.emit_u8(kWasmFunctionTypeForm);
+                    section.emit_u32v(type.params.length);
+                    for (let param of type.params) {
+                        section.emit_u8(param);
+                    }
+                    section.emit_u32v(type.results.length);
+                    for (let result of type.results) {
+                        section.emit_u8(result);
+                    }
+                }
+            });
+            binary.emit_section(kImportSectionCode, section => {
+                section.emit_u32v(wasm.imports.length);
+                for (let imp of wasm.imports) {
+                    section.emit_string(imp.module);
+                    section.emit_string(imp.name || '');
+                    section.emit_u8(imp.kind);
+                    if (imp.kind == kExternalFunction) {
+                        section.emit_u32v(imp.type);
+                    }
+                }
+            });
+            binary.emit_section(kFunctionSectionCode, section => {
+                section.emit_u32v(wasm.functions.length);
+                for (let func of wasm.functions) {
+                    section.emit_u32v(func.type_index);
+                }
+            });
+        }
+        var mem_export = (wasm.memory !== undefined && wasm.memory.exp);
+        var exports_count = wasm.exports.length + (mem_export ? 1 : 0);
+        if (exports_count > 0) {
+            binary.emit_section(kExportSectionCode, section => {
+                section.emit_u32v(exports_count);
+                for (let exp of wasm.exports) {
+                    section.emit_string(exp.name);
+                    section.emit_u8(exp.kind);
+                    section.emit_u8(0);
+                }
+            });
+        }
+        if (wasm.start_index !== undefined) {
+        }
+        if (wasm.functions.length > 0) {
+            binary.emit_section(kCodeSectionCode, section => {
+                section.emit_u32v(wasm.functions.length);
+                for (let func of wasm.functions) {
+                    let local_decls = [];
+                    let header = new Binary;
+                    header.emit_u32v(local_decls.length);
+                    section.emit_u32v(header.length + func.body.length);
+                    section.emit_bytes(header);
+                    section.emit_bytes(func.body);
+                }
+            });
+        }
+        let num_function_names = 0;
+        let num_functions_with_local_names = 0;
+        if (num_function_names > 0 || num_functions_with_local_names > 0 || wasm.name !== undefined) {
+            binary.emit_section(kUnknownSectionCode, section => {
+                if (num_function_names > 0) {
+                }
+            });
+        }
+        return binary;
+    }
+    toBuffer(debug = false) {
+        let bytes = this.toArray(debug);
+        let buffer = new ArrayBuffer(bytes.length);
+        let view = new Uint8Array(buffer);
+        for (let i = 0; i < bytes.length; i++) {
+            let val = bytes[i];
+            view[i] = val | 0;
+        }
+        return buffer;
+    }
+    toModule(debug = false) {
+        return new WebAssembly.Module(this.toBuffer(debug));
+    }
+}
+const verifyHeap = gc;
+function testProperties(obj) {
+    for (let i = 0; i < 3; i++) {
+        verifyHeap();
+    }
+}
+(function ExportedFunctionTest() {
+    var builder = new WasmModuleBuilder();
+    builder.addFunction("exp", kSig_i_i).addBody([
+        kExprGetLocal, 0,
+    ]).exportAs("exp");
+    let module1 = builder.toModule();
+    let instance1 = new WebAssembly.Instance(module1);
+    let g = instance1.exports.exp;
+    testProperties(g);
+    builder.addImport("imp", "func", kSig_i_i);
+    let module2 = builder.toModule();
+    let instance2 = new WebAssembly.Instance(module2, {
+        imp: {
+            func: g
+        }
+    });
+})();
diff --git a/js/src/jit-test/tests/wasm/regress/bug1450800.js b/js/src/jit-test/tests/wasm/regress/bug1450800.js
new file mode 100644
index 0000000000..fb8493c102
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1450800.js
@@ -0,0 +1,27 @@
+// |jit-test| skip-if: !this.gczeal || !WebAssembly.Global
+
+gczeal(9, 10);
+function wasmEvalText(str, imports) {
+    let binary = wasmTextToBinary(str);
+    m = new WebAssembly.Module(binary);
+    return new WebAssembly.Instance(m, imports);
+}
+assertEq(wasmEvalText(`(module
+                        (global (import "a" "b") i32)
+                        (export "g" (global 0))
+                        (func (export "get") (result i32) global.get 0))`,
+                      { a: { b: 42 }}).exports.get(),
+         42);
+for (let v of []) {}
+function testInitExpr(type, initialValue, nextValue, coercion, assertFunc = assertEq) {
+    var module = wasmEvalText(`(module
+        (import "globals" "a" (global ${type}))
+        (global $glob_imm ${type} (global.get 0))
+        (export "global_imm" (global $glob_imm))
+    )`, {
+        globals: {
+            a: coercion(initialValue)
+        }
+    }).exports;
+}
+testInitExpr('i32', 13, 37, x => x | 0);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1467415.js b/js/src/jit-test/tests/wasm/regress/bug1467415.js
new file mode 100644
index 0000000000..177e67ba08
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1467415.js
@@ -0,0 +1,29 @@
+
+// This exposed an alias analysis bug in the Wasm Ion machinery.  It should
+// compute 125 (88 + 37) but with the bug would compute 176 (88 + 88) instead.
+// See bug 1467415.
+
+let mt = `
+(module
+  (import "m" "g" (global (mut i32)))
+  (import "m" "h" (global (mut i32)))
+  (memory 1 1)
+  (data (i32.const 0) "\\01\\00\\00\\00\\01\\00\\00\\00\\01\\00\\00\\00")
+  (func (export "f") (result i32)
+    (local i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (global.get 0))
+      (block (result i32)
+        (global.set 1 (i32.const 37))
+        (block (result i32)
+          (local.set 1 (global.get 0))
+          (i32.add (local.get 0) (local.get 1)))))))
+`;
+
+let glob = new WebAssembly.Global({value:'i32', mutable:true}, 88);
+let module = new WebAssembly.Module(wasmTextToBinary(mt));
+let ins = new WebAssembly.Instance(module, {m:{g:glob, h:glob}});
+
+let shouldBe125 = ins.exports.f();
+assertEq(shouldBe125, 125);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1491322.js b/js/src/jit-test/tests/wasm/regress/bug1491322.js
new file mode 100644
index 0000000000..ae3d6a0e73
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1491322.js
@@ -0,0 +1,35 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+var evalInFrame = (function(global) {
+    var dbgGlobal = newGlobal({newCompartment: true});
+    var dbg = new dbgGlobal.Debugger();
+    dbg.addDebuggee(global);
+})(this);
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+var m = new Module(wasmTextToBinary(`(module
+    (import "" "foo" (func $foo (result i32)))
+    (import "" "bar" (func $bar (result i32)))
+    (table 3 funcref)
+    (func $baz (result i32) (i32.const 13))
+    (elem (i32.const 0) $foo $bar $baz)
+    (export "tbl" (table 0))
+)`));
+var jsFun = () => 83;
+var wasmFun = new Instance(
+  new Module(
+    wasmTextToBinary('(module (func (result i32) (i32.const 42)) (export "foo" (func 0)))')
+  )
+).exports.foo;
+var e1 = new Instance(m, {
+    "": {
+        foo: jsFun,
+        bar: wasmFun
+    }
+}).exports;
+var e2 = new Instance(m, {
+    "": {
+        foo: jsFun,
+        bar: jsFun
+    }
+}).exports;
+e2.tbl.get(0);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1502886.js b/js/src/jit-test/tests/wasm/regress/bug1502886.js
new file mode 100644
index 0000000000..a45bf774a4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1502886.js
@@ -0,0 +1,30 @@
+newGlobal({newCompartment: true});
+g = newGlobal({newCompartment: true});
+var dbg = Debugger(g);
+gczeal(2, 100);
+function f(x, initFunc) {
+    newGlobal({newCompartment: true});
+    g.eval(`
+        var binary = wasmTextToBinary('${x}');
+        new WebAssembly.Instance(new WebAssembly.Module(binary));
+    `);
+    var wasmScript = dbg.findScripts().filter(s => s.format == 'wasm')[0];
+    var offsets = wasmScript.getPossibleBreakpointOffsets();
+    initFunc({
+        wasmScript,
+        breakpoints: offsets
+    })
+};
+try {
+    f('(module (func nop nop) (export "" (func 0)))',
+        function({
+            wasmScript,
+            breakpoints
+        }) {
+            breakpoints.forEach(function(offset) {
+                wasmScript.setBreakpoint(offset, s = {});
+            });
+        }
+    );
+    f();
+} catch (e) {}
diff --git a/js/src/jit-test/tests/wasm/regress/bug1507314.js b/js/src/jit-test/tests/wasm/regress/bug1507314.js
new file mode 100644
index 0000000000..db07593d87
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1507314.js
@@ -0,0 +1,6 @@
+// |jit-test| --no-sse4
+if (!wasmCachingEnabled())
+    quit(0);
+
+var m = wasmCompileInSeparateProcess(wasmTextToBinary('(module (func (export "run") (result i32) (i32.const 42)))'));
+assertEq(new WebAssembly.Instance(m).exports.run(), 42);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1533204.js b/js/src/jit-test/tests/wasm/regress/bug1533204.js
new file mode 100644
index 0000000000..e901fd066b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1533204.js
@@ -0,0 +1,10 @@
+// |jit-test| skip-if: helperThreadCount() === 0
+enableOsiPointRegisterChecks();
+evalInWorker(`
+function DiagModule(stdlib, foreign) {
+    "use asm";
+    function diag() {
+        while(1) {}
+    }
+    return {};
+`);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1566992.js b/js/src/jit-test/tests/wasm/regress/bug1566992.js
new file mode 100644
index 0000000000..52d2c0710c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1566992.js
@@ -0,0 +1,14 @@
+let { exports: { f } } = wasmEvalText(`
+(module
+    (func (export "f")
+        (block
+            i64.const 0xfffffffe00000000
+            i32.wrap_i64
+            br_table 0 1
+        )
+        unreachable
+    )
+)
+`);
+
+assertErrorMessage(f, WebAssembly.RuntimeError, /unreachable/);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1569137.js b/js/src/jit-test/tests/wasm/regress/bug1569137.js
new file mode 100644
index 0000000000..fc0a4a3c39
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1569137.js
@@ -0,0 +1,65 @@
+let { exports: { f } } = wasmEvalText(`
+(module
+ (memory $0 1 1)
+
+ (func (export "f") (result f32)
+  (local $0 i32) (local $1 f64) (local $2 i32)
+
+  (set_local 0 (i32.const 134219779))
+  (set_local 1 (f64.const 3810600700439633677210579e165))
+
+  (f32.floor
+   (loop $label$2 (result f32)
+    (br_if $label$2
+     (i32.load offset=3 align=2
+       (block $label$4 (result i32)
+        (drop
+         (if (result f64)
+             (br_if $label$4
+              (i32.const 4883)
+                (i32.const -124)
+          )
+          (f64.const 77)
+          (block (result f64)
+           (drop
+             (br_if $label$4
+              (i32.const 4194304)
+              (i32.const -8192)
+            )
+           )
+           (return
+            (f32.const 4294967296)
+           )
+          )
+         )
+        )
+          (br_if $label$4
+             (br_if $label$4
+              (i32.const -90)
+               (br_if $label$4
+                (br_if $label$4
+                 (local.get $2)
+                 (i32.const -16)
+                )
+                (i32.const 15656)
+               )
+             )
+          (block $label$18 (result i32)
+           (i32.eqz
+            (br_if $label$4
+                 (i32.const -1)
+                 (i32.const 15)
+           )
+          )
+         )
+        )
+       )
+     )
+    )
+    (f32.const 23)
+   )
+  )
+ )
+)`);
+
+f();
diff --git a/js/src/jit-test/tests/wasm/regress/bug1590920.js b/js/src/jit-test/tests/wasm/regress/bug1590920.js
new file mode 100644
index 0000000000..1f92db1129
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1590920.js
@@ -0,0 +1,11 @@
+let { exports } = new WebAssembly.Instance(new WebAssembly.Module(
+    wasmTextToBinary(`
+      (module
+        (func (export "g")
+          (drop
+            (block (result i32)
+              (i32.clz (i32.const 1))
+              (if
+                (i32.const 1)
+                (return))))))`)));
+exports.g();
diff --git a/js/src/jit-test/tests/wasm/regress/bug1678542.js b/js/src/jit-test/tests/wasm/regress/bug1678542.js
new file mode 100644
index 0000000000..8c3f44fa6d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1678542.js
@@ -0,0 +1,11 @@
+var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (global $g (export "g") (mut f64) (f64.const 0))
+  (func $p (param f64) (result f64) (local.get 0))
+  (func (export "f") (param f64) (result f64)
+    (global.set $g (f64.neg (local.get 0)))
+    (call $p (local.get 0))))`)));
+assertEq(ins.exports.f(3), 3);
+assertEq(ins.exports.g.value, -3);
+
+
diff --git a/js/src/jit-test/tests/wasm/regress/bug1678785.js b/js/src/jit-test/tests/wasm/regress/bug1678785.js
new file mode 100644
index 0000000000..b04ac8480b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1678785.js
@@ -0,0 +1,20 @@
+
+// This exposed a bug in CL's aarch64 isel, in which the -4098 was
+// incorrectly sign-extended out to 64 bits.
+
+let { exports } = new WebAssembly.Instance(new WebAssembly.Module(
+    wasmTextToBinary(`
+      (module
+        (type (;0;) (func))
+        (type (;1;) (func (result i32)))
+        (type (;2;) (func (result i64)))
+        (func (;0;) (type 0)
+          i32.const -4098
+          i32.load16_s offset=1
+          drop)
+        (memory (;0;) 1)
+        (export "g" (func 0)))` )));
+try {
+    exports.g();
+} catch (e) {}
+
diff --git a/js/src/jit-test/tests/wasm/regress/bug1684861.js b/js/src/jit-test/tests/wasm/regress/bug1684861.js
new file mode 100644
index 0000000000..4cb9bb2383
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1684861.js
@@ -0,0 +1,54 @@
+const oob = /index out of bounds/;
+const unaligned = /unaligned memory access/;
+const RuntimeError = WebAssembly.RuntimeError;
+
+// Test memory.atomic.notify unaligned access.
+const module = new WebAssembly.Module(wasmTextToBinary(`(module
+  (type (;0;) (func))
+  (func $main (type 0)
+    i32.const -64
+    i32.const -63
+    memory.atomic.notify offset=1
+    unreachable)
+  (memory (;0;) 4 4)
+  (export "main" (func $main)))`));
+
+const instance = new WebAssembly.Instance(module);
+assertErrorMessage(() => instance.exports.main(), RuntimeError, unaligned);
+
+// Test memory.atomic.notify oob access.
+const module2 = new WebAssembly.Module(wasmTextToBinary(`(module
+  (type (;0;) (func))
+  (func $main (type 0)
+    i32.const -64
+    i32.const -63
+    memory.atomic.notify offset=65536
+    unreachable)
+  (memory (;0;) 4 4)
+  (export "main" (func $main)))`));
+
+const instance2 = new WebAssembly.Instance(module2);
+assertErrorMessage(() => instance2.exports.main(), RuntimeError, oob);
+
+// Test memory.atomic.wait32 and .wait64 unaligned access.
+const module3 = new WebAssembly.Module(wasmTextToBinary(`(module
+  (type (;0;) (func))
+  (func $wait32 (type 0)
+    i32.const -64
+    i32.const 42
+    i64.const 0
+    memory.atomic.wait32 offset=1
+    unreachable)
+  (func $wait64 (type 0)
+    i32.const -64
+    i64.const 43
+    i64.const 0
+    memory.atomic.wait64 offset=3
+    unreachable)
+  (memory (;0;) 4 4 shared)
+  (export "wait32" (func $wait32))
+  (export "wait64" (func $wait64)))`));
+
+const instance3 = new WebAssembly.Instance(module3);
+assertErrorMessage(() => instance3.exports.wait32(), RuntimeError, unaligned);
+assertErrorMessage(() => instance3.exports.wait64(), RuntimeError, unaligned);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1699647.js b/js/src/jit-test/tests/wasm/regress/bug1699647.js
new file mode 100644
index 0000000000..499b88b36d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1699647.js
@@ -0,0 +1,10 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !getBuildConfiguration().x86
+
+const module = new Uint8Array([
+    0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,
+    5,4,1,1,0,0,7,10,1,6,109,101,109,111,114,121,2,0,10,49,
+    1,47,0,65,16,253,1,1,1,253,253,1,253,131,1,65,158,232,
+    68,253,1,1,1,253,100,65,16,253,1,1,1,253,11,0,0,253,1,1,
+    1,65,158,232,68,253,1,1,0,0,11,0,14,4,110,97,109,101,1,
+    7,1,0,4,109,97,105,110]);
+new WebAssembly.Module(module)
diff --git a/js/src/jit-test/tests/wasm/regress/bug1700610.js b/js/src/jit-test/tests/wasm/regress/bug1700610.js
new file mode 100644
index 0000000000..ce8b032074
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1700610.js
@@ -0,0 +1,8 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !getBuildConfiguration().x86
+
+const module = new Uint8Array([
+    0,97,115,109,1,0,0,0,1,6,1,96,1,127,1,111,3,2,1,0,5,4,1,1,0,0,10,38,1,36,
+    0,65,1,253,4,0,81,253,21,1,253,4,0,81,253,21,0,253,1,0,81,253,21,1,253,4,
+    0,81,253,21,0,50,0,0,0,11,0,14,4,110,97,109,101,1,7,1,0,4,109,97,105,110
+]);
+new WebAssembly.Module(module)
diff --git a/js/src/jit-test/tests/wasm/regress/bug1708124.js b/js/src/jit-test/tests/wasm/regress/bug1708124.js
new file mode 100644
index 0000000000..dc035b02e5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1708124.js
@@ -0,0 +1,10 @@
+// |jit-test| skip-if: !('oomTest' in this)
+// Ensure that trap reporting mechanism doesn't crash under OOM conditions.
+
+oomTest(
+  wasmEvalText(
+    `(module
+       (func (export "f") (result)
+         unreachable))`
+  ).exports.f
+);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1713581.js b/js/src/jit-test/tests/wasm/regress/bug1713581.js
new file mode 100644
index 0000000000..a7201ccb22
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1713581.js
@@ -0,0 +1,13 @@
+function wasmEvalText(str, imports, options) {
+  let binary = wasmTextToBinary(str);
+  m = new WebAssembly.Module(binary, options);
+  return new WebAssembly.Instance(m, imports);
+}
+let ins = wasmEvalText(`
+  (module
+    (func (export "fill0") (param $r externref))
+  )
+`);
+for (let i53 = 0; i53 < 1000; i53++) {
+  ins.exports.fill0("hello")
+}
diff --git a/js/src/jit-test/tests/wasm/regress/bug1727284/directives.txt b/js/src/jit-test/tests/wasm/regress/bug1727284/directives.txt
new file mode 100644
index 0000000000..82e51d5a01
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1727284/directives.txt
@@ -0,0 +1 @@
+|jit-test| --fast-warmup; --ion-warmup-threshold=0; --wasm-compiler=optimizing; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/regress/bug1727284/test.js b/js/src/jit-test/tests/wasm/regress/bug1727284/test.js
new file mode 100644
index 0000000000..54d7350be9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1727284/test.js
@@ -0,0 +1,12 @@
+function test() {
+  let instance = wasmEvalText(`
+    (module
+      (global $g (mut externref) (ref.null extern))
+      (func (export "set") (param externref) local.get 0 global.set $g)
+    )
+  `).exports;
+  let obj = { field: null };
+  instance.set(obj);
+  for (var v4 = 0; v4 < 10; v4++) {}
+}
+test();
diff --git a/js/src/jit-test/tests/wasm/regress/bug1747870.js b/js/src/jit-test/tests/wasm/regress/bug1747870.js
new file mode 100644
index 0000000000..2625e965fb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1747870.js
@@ -0,0 +1,19 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// This should not release-assert, which it could previously do on some 32-bit
+// platforms due to the too-limited size of a bitfield.
+
+const MaxParams = 1000;         // Per spec
+
+var params = '';
+for ( var i=0 ; i < MaxParams-1; i++ ) {
+    params += '(param v128) '
+}
+params += '(param externref)'
+
+new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func $f)
+  (func ${params} (result externref)
+    (call $f)
+    (local.get ${MaxParams-1})))`));
diff --git a/js/src/jit-test/tests/wasm/regress/bug1761850.js b/js/src/jit-test/tests/wasm/regress/bug1761850.js
new file mode 100644
index 0000000000..609991bde4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1761850.js
@@ -0,0 +1,79 @@
+// Testing runtime execution of select + comparison operations.
+// Normally they are folded into shorter/faster sequence than select alone.
+
+const floatOps = {
+    lt(a, b) { return a < b ? 0 : 1; },
+    le(a, b) { return a <= b ? 0 : 1; },
+    gt(a, b) { return a > b ? 0 : 1; },
+    ge(a, b) { return a >= b ? 0 : 1; },
+    eq(a, b) { return a === b ? 0 : 1; },
+    ne(a, b) { return a !== b ? 0 : 1; },
+}
+
+for (let ty of ['f32', 'f64']) {
+    for (let op of ['lt', 'le', 'gt', 'ge', 'eq', 'ne']) {
+        const module = new WebAssembly.Module(wasmTextToBinary(`(module
+            (memory (export "memory") 1 1)
+            (func (export "test") (result i32)
+                i32.const 128
+                i32.load8_u
+                i32.const 129
+                i32.load8_u
+                i32.const 0
+                ${ty}.load
+                i32.const ${ty == 'f32' ? 4 : 8}
+                ${ty}.load
+                ${ty}.${op}
+                select
+            )
+            (data (i32.const 128) "\\00\\01"))`));
+        const instance = new WebAssembly.Instance(module);
+        const arr = new (ty == 'f32' ? Float32Array : Float64Array)(instance.exports.memory.buffer);
+        for (let [a, b] of cross(
+            [0, 1, -1e100, Infinity, -Infinity, 1e100, -1e-10, 1/-Infinity, NaN]
+        )) {
+            arr[0] = a; arr[1] = b;
+            assertEq(instance.exports.test(), floatOps[op](arr[0], arr[1]))
+        }
+    }
+}
+
+const intOps = {
+    lt(a, b) { return a < b ? 0 : 1; },
+    le(a, b) { return a <= b ? 0 : 1; },
+    gt(a, b) { return a > b ? 0 : 1; },
+    ge(a, b) { return a >= b ? 0 : 1; },
+    eq(a, b) { return a === b ? 0 : 1; },
+    ne(a, b) { return a !== b ? 0 : 1; },
+}
+
+for (let [ty, signed] of [['i32', true], ['i32', false], ['i64', true], ['i64', false]]) {
+    for (let op of ['lt', 'le', 'gt', 'ge', 'eq', 'ne']) {
+        const module = new WebAssembly.Module(wasmTextToBinary(`(module
+            (memory (export "memory") 1 1)
+            (func (export "test") (result i32)
+                i32.const 128
+                i32.load8_u
+                i32.const 129
+                i32.load8_u
+                i32.const 0
+                ${ty}.load
+                i32.const ${ty == 'i32' ? 4 : 8}
+                ${ty}.load
+                ${ty}.${op}${op[0] == 'l' || op[0] == 'g' ? (signed ? '_s' : '_u') : ''}
+                select
+            )
+            (data (i32.const 128) "\\00\\01"))`));
+        const instance = new WebAssembly.Instance(module);
+        const arr = new (ty == 'i32' ? (signed ? Int32Array : Uint32Array) :
+                                       (signed ? BigInt64Array : BigUint64Array))
+                        (instance.exports.memory.buffer);
+        const c = ty == 'i32' ? (a => a|0) : BigInt;
+        for (let [a, b] of cross(
+            [c(0), ~c(0), c(1), ~c(1), c(1) << c(8), ~c(1) << c(12)]
+        )) {
+            arr[0] = a; arr[1] = b;
+            assertEq(instance.exports.test(), intOps[op](arr[0], arr[1]))
+        }
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/regress/bug1762899.js b/js/src/jit-test/tests/wasm/regress/bug1762899.js
new file mode 100644
index 0000000000..3938c93a02
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1762899.js
@@ -0,0 +1,34 @@
+var ins = wasmEvalText(`
+(module
+  (func (export "copysign_f64") (param f64 f64) (result f64)
+    f64.const 0x1.921fb54442d18p+0 (;=1.5708;)
+    local.get 0
+    f64.copysign
+  )
+  (func (export "copysign_f32") (param f32 f32) (result f32)
+    f32.const 0x1.921fb54442d18p+0 (;=1.5708;)
+    local.get 0
+    f32.copysign
+  )
+  (func (export "copysign_f64_2") (param f64 f64) (result f64)
+    local.get 1
+    f64.const 0x1.921fb54442d18p+0 (;=1.5708;)
+    f64.copysign
+  )
+  (func (export "copysign_f32_2") (param f32 f32) (result f32)
+    local.get 1
+    f32.const -0x1.921fb54442d18p+0 (;=1.5708;)
+    f32.copysign
+  )
+
+)
+`);
+
+assertEq(ins.exports.copysign_f64(1, 0), 1.5707963267948966);
+assertEq(ins.exports.copysign_f64(-1, 0), -1.5707963267948966);
+assertEq(ins.exports.copysign_f32(1, 0), 1.5707963705062866);
+assertEq(ins.exports.copysign_f32(-1, 0), -1.5707963705062866);
+assertEq(ins.exports.copysign_f64_2(0, 1), 1);
+assertEq(ins.exports.copysign_f64_2(0, -1), 1);
+assertEq(ins.exports.copysign_f32_2(0, 1), -1);
+assertEq(ins.exports.copysign_f32_2(0, -1), -1);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1770335.js b/js/src/jit-test/tests/wasm/regress/bug1770335.js
new file mode 100644
index 0000000000..569d7bd35e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1770335.js
@@ -0,0 +1,33 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Check if GVN indentifies two non-indentical shuffles. During value numbering
+// the control field/data might look the same. Shuffle or permute kind, and
+// operands order have to be taking into account during value numbering.
+// If GVN fails to recognize the following shuffles as different, the v128.xor
+// produces zero output.
+var ins = wasmEvalText(`(module
+    (memory (export "memory") 1 1)
+    (func $test (param v128) (result v128)
+        local.get 0
+        v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000
+        i8x16.shuffle 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
+        v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000
+        local.get 0
+        i8x16.shuffle 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
+        v128.xor
+    )
+    (func (export "run")
+        i32.const 16
+        i32.const 0
+        v128.load
+        call $test
+        v128.store
+    )
+)`);
+
+const mem64 = new BigInt64Array(ins.exports.memory.buffer, 0, 4);
+mem64[0] = 0x123456789n;
+mem64[1] = -0xFDCBA000n;
+ins.exports.run();
+assertEq(mem64[2], -0xFDCBA000n);
+assertEq(mem64[3], 0x123456789n);
diff --git a/js/src/jit-test/tests/wasm/regress/bug1836708.js b/js/src/jit-test/tests/wasm/regress/bug1836708.js
new file mode 100644
index 0000000000..87b7483bd6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/bug1836708.js
@@ -0,0 +1,19 @@
+// Testing i64.mul in wasm with a 2 ** n +- 1 value as operand, which may
+// be optimized in code generation.
+var mulImmOperands = [];
+
+for (let i = 0n; i < 64n; i++) {
+  mulImmOperands.push(2n ** i - 1n);
+  mulImmOperands.push(2n ** i + 1n);
+}
+
+for (const immVal of mulImmOperands) {
+  const ins = wasmEvalText(`(module
+    (func (export "mul_i64") (param i64) (result i64)
+      local.get 0
+      i64.const ${immVal}
+      i64.mul
+    ))`);
+
+  assertEq(ins.exports.mul_i64(42n), BigInt.asIntN(64, 42n * immVal));
+}
diff --git a/js/src/jit-test/tests/wasm/regress/builtin-import-sigs.js b/js/src/jit-test/tests/wasm/regress/builtin-import-sigs.js
new file mode 100644
index 0000000000..50aa2a41d1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/builtin-import-sigs.js
@@ -0,0 +1,15 @@
+var code = wasmTextToBinary(`(module
+    (import "" "builtin" (func $one))
+    (import "" "builtin" (func $two (param i32)))
+    (import "" "builtin" (func $three (result i32)))
+    (import "" "builtin" (func $four (param f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32 f32) (result f32)))
+    (func (export "run")
+        (call $one)
+        (call $two (i32.const 0))
+        (drop (call $three))
+        (drop (call $four (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f32.const 0)))
+    )
+)`);
+var m = new WebAssembly.Module(code);
+var i = new WebAssembly.Instance(m, {'':{builtin:Math.sin}});
+i.exports.run();
diff --git a/js/src/jit-test/tests/wasm/regress/caller-property.js b/js/src/jit-test/tests/wasm/regress/caller-property.js
new file mode 100644
index 0000000000..8b9a95a989
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/caller-property.js
@@ -0,0 +1,7 @@
+const { g } = wasmEvalText(`(module (func $f) (export "g" (func $f)))`).exports;
+
+function testCaller() {
+  return g.caller;
+}
+
+assertErrorMessage(testCaller, TypeError, /caller/);
diff --git a/js/src/jit-test/tests/wasm/regress/current-memory-tls.js b/js/src/jit-test/tests/wasm/regress/current-memory-tls.js
new file mode 100644
index 0000000000..6bd46b2b5f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/current-memory-tls.js
@@ -0,0 +1,95 @@
+// Bug 1341650:
+// - when compiled with Ion, pass the TLS register to memory.size;
+// - when compiled with Baseline, don't clobber the last stack slot when
+// calling into memory.size/memory.grow;
+
+// This toy module starts with an empty memory, then tries to set values at different
+// indexes, automatically growing memory when that would trigger an out of
+// bounds access, for the exact right amount of pages. Note it's not made for
+// efficiency, but optimizing it doesn't trigger the bugs mentioned above.
+
+let i = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (memory $mem (export "mem") 0 65535)
+
+    (func (export "cur_mem") (result i32) (memory.size))
+
+    (func $maybeGrow (param $i i32) (local $smem i32)
+     ;; get memory.size in number of bytes, not pages.
+     memory.size
+     i64.extend_u/i32
+     i64.const 65536
+     i64.mul
+
+     ;; get the last byte index accessed by an int32 access.
+     local.get $i
+     i32.const 3
+     i32.add
+     tee_local $i
+     i64.extend_u/i32
+
+     ;; if the memory is too small, grow it.
+     i64.le_u
+     if
+         ;; get the floor of the accessed *page* index.
+         local.get $i
+         i64.extend_u/i32
+         i64.const 65536
+         i64.div_u
+
+         ;; subtract to that the size of the current memory in pages;
+         ;; that's the amount of pages we want to grow, minus one.
+         memory.size
+         i64.extend_u/i32
+
+         i64.sub
+
+         ;; add 1 to that amount.
+         i64.const 1
+         i64.add
+
+         ;; get back to i32 and grow memory.
+         i32.wrap/i64
+         memory.grow
+         drop
+     end
+    )
+
+    (func (export "set") (param $i i32) (param $v i32)
+     local.get $i
+     call $maybeGrow
+     local.get $i
+     local.get $v
+     i32.store
+    )
+
+    (func (export "get") (param $i i32) (result i32)
+     local.get $i
+     i32.load
+    )
+)
+`))).exports;
+
+assertEq(i.cur_mem(), 0);
+
+i.set(0, 1);
+assertEq(i.get(0), 1);
+
+assertEq(i.cur_mem(), 1);
+
+i.set(1234, 1);
+assertEq(i.get(1234), 1);
+
+assertEq(i.cur_mem(), 1);
+
+i.set(65532, 1);
+assertEq(i.get(65532), 1);
+
+assertErrorMessage(() => i.get(65533), WebAssembly.RuntimeError, /index out of bounds/);
+
+assertEq(i.cur_mem(), 1);
+
+i.set(65533, 1);
+assertEq(i.get(65533), 1);
+
+assertEq(i.cur_mem(), 2);
diff --git a/js/src/jit-test/tests/wasm/regress/debug-clone-segment.js b/js/src/jit-test/tests/wasm/regress/debug-clone-segment.js
new file mode 100644
index 0000000000..f91f62df32
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/debug-clone-segment.js
@@ -0,0 +1,36 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+//
+var mod = new WebAssembly.Module(wasmTextToBinary(`
+    (module
+        (func (export "func_0") (result i32)
+         call 0
+        )
+    )
+`));
+
+var g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval("(" + function() {
+    var dbg = Debugger(parent);
+    dbg.onEnterFrame = function(frame) {}
+} + ")()");
+
+processModule(mod);
+processModule(mod);
+processModule(mod);
+processModule(mod);
+
+mod = new WebAssembly.Module(wasmTextToBinary(`
+(module (export "func_0" (func $func1)) (func $func1))
+`));
+
+processModule(mod);
+processModule(mod);
+processModule(mod);
+processModule(mod);
+
+function processModule(module) {
+    try {
+        new WebAssembly.Instance(module).exports.func_0();
+    } catch(ex) {}
+}
diff --git a/js/src/jit-test/tests/wasm/regress/debug-exception-in-fast-import.js b/js/src/jit-test/tests/wasm/regress/debug-exception-in-fast-import.js
new file mode 100644
index 0000000000..bba37b38b0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/debug-exception-in-fast-import.js
@@ -0,0 +1,21 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval("(" + function() {
+    Debugger(parent).onExceptionUnwind = function(frame) {}
+} + ")()")
+
+o = {};
+
+let { exports } = wasmEvalText(`
+  (module (import "" "inc" (func $imp)) (func) (func $start (call $imp)) (start $start) (export "" (func $start)))
+`, {
+    "": {
+        inc: function() { o = o.p; }
+    }
+});
+
+// after instanciation, the start function has been executed and o is undefined.
+// This second call will throw in the imported function:
+
+assertErrorMessage(exports[""], TypeError, /undefined/);
diff --git a/js/src/jit-test/tests/wasm/regress/debug-osr.js b/js/src/jit-test/tests/wasm/regress/debug-osr.js
new file mode 100644
index 0000000000..e8d3285ed4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/debug-osr.js
@@ -0,0 +1,16 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled()
+g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval("(" + function() {
+    Debugger(parent).onExceptionUnwind = function(frame) {
+        frame.older
+    }
+} + ")()");
+
+let o = {};
+
+let func = wasmEvalText(`
+  (module (import "" "inc" (func $imp)) (func) (func $start (call $imp)) (start $start) (export "" (func $start)))
+`, { "": { inc: function() { o = o.set; } } }).exports[""];
+
+assertErrorMessage(func, TypeError, /(is|of) undefined/);
diff --git a/js/src/jit-test/tests/wasm/regress/directives.txt b/js/src/jit-test/tests/wasm/regress/directives.txt
new file mode 100644
index 0000000000..8bb976be49
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/regress/enable-profiling-in-import.js b/js/src/jit-test/tests/wasm/regress/enable-profiling-in-import.js
new file mode 100644
index 0000000000..dd17b2089f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/enable-profiling-in-import.js
@@ -0,0 +1,9 @@
+var module = new WebAssembly.Module(wasmTextToBinary(`
+    (module
+        (import "global" "func" (func))
+        (func (export "f")
+         call 0
+        )
+    )
+`));
+new WebAssembly.Instance(module, { global: { func: enableGeckoProfiling } }).exports.f();
diff --git a/js/src/jit-test/tests/wasm/regress/frame-offset-stack-arg.js b/js/src/jit-test/tests/wasm/regress/frame-offset-stack-arg.js
new file mode 100644
index 0000000000..6ab2834d79
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/frame-offset-stack-arg.js
@@ -0,0 +1,38 @@
+// We have some register args and the rest are on the stack in the wasm->js
+// call.  This tests a case where the wrong frame offset was used (on ARM64,
+// which is weird in this regard) to read the stack arg in an optimized callout
+// stub.
+
+var loop_counter = 0;
+
+function f(a,b,c,d,e,f,g,h,i,j) {
+    assertEq(a, loop_counter);
+    assertEq(b, a+1);
+    assertEq(c, b+1);
+    assertEq(d, c+1);
+    assertEq(e, d+1);
+    assertEq(f, e+1);
+    assertEq(g, f+1);
+    assertEq(h, g+1);
+    assertEq(i, h+1);
+    assertEq(j, i+1);
+}
+
+var bin = wasmTextToBinary(
+    `(module
+       (import "m" "f" (func $f (param i32) (param i32) (param i32) (param i32) (param i32)
+                                (param i32) (param i32) (param i32) (param i32) (param i32)))
+       (func (export "test") (param $a i32) (param $b i32) (param $c i32) (param $d i32) (param $e i32)
+                             (param $f i32) (param $g i32) (param $h i32) (param $i i32) (param $j i32)
+         (call $f (local.get $a) (local.get $b) (local.get $c) (local.get $d) (local.get $e)
+                  (local.get $f) (local.get $g) (local.get $h) (local.get $i) (local.get $j))))`);
+
+var mod = new WebAssembly.Module(bin);
+var ins = new WebAssembly.Instance(mod, {m:{f}});
+
+// Enough iterations for the jit to kick in and the stub to become optimized.
+
+for ( let i=0; i < 100; i++ ) {
+    loop_counter = i;
+    ins.exports.test(i, i+1, i+2, i+3, i+4, i+5, i+6, i+7, i+8, i+9);
+}
diff --git a/js/src/jit-test/tests/wasm/regress/fuzzsafe-bug1645610.js b/js/src/jit-test/tests/wasm/regress/fuzzsafe-bug1645610.js
new file mode 100644
index 0000000000..6bd88e95bc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/fuzzsafe-bug1645610.js
@@ -0,0 +1,15 @@
+// |jit-test| --fuzzing-safe; skip-if: this.getErrorNotes
+//
+// The meaning of the line above is that the test case is to be run only with
+// --fuzzing-safe and only if that setting (or similar settings) is effectful.
+
+WebAssembly.Module.exports(new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (;0;))
+  (func (;1;))
+  (func (;2;))
+  (func (;3;) (result i32)
+    i32.const 42)
+  (export "memo" (func 3))
+  (export "main" (func 3)))
+`)));
diff --git a/js/src/jit-test/tests/wasm/regress/gvn-unremovable-phi.js b/js/src/jit-test/tests/wasm/regress/gvn-unremovable-phi.js
new file mode 100644
index 0000000000..832215f4e6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/gvn-unremovable-phi.js
@@ -0,0 +1,20 @@
+wasmEvalText(`(module
+  (type $type0 (func (param i32)))
+  (func $f (param $p i32)
+    (local $x i32) (local $y i32)
+    loop $top
+      local.get $x
+      local.get $p
+      local.get $x
+      br_if $top
+      i32.const 1
+      tee_local $p
+      local.get $y
+      local.set $x
+      i32.add
+      call $f
+      br_if $top
+      return
+    end
+  )
+)`);
diff --git a/js/src/jit-test/tests/wasm/regress/imul64-ion-negative-power-of-two.js b/js/src/jit-test/tests/wasm/regress/imul64-ion-negative-power-of-two.js
new file mode 100644
index 0000000000..0fe59546d7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/imul64-ion-negative-power-of-two.js
@@ -0,0 +1,11 @@
+new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (func (param i64))
+    (func (export "f")
+        i64.const 2
+        i64.const -9223372036854775808
+        i64.mul
+        call 0
+    )
+)
+`))).exports.f();
diff --git a/js/src/jit-test/tests/wasm/regress/ion-callerfp-tag.js b/js/src/jit-test/tests/wasm/regress/ion-callerfp-tag.js
new file mode 100644
index 0000000000..936fba24fd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/ion-callerfp-tag.js
@@ -0,0 +1,28 @@
+var lfModule = new WebAssembly.Module(wasmTextToBinary(`
+    (module
+        (import "global" "func" (func (result i32)))
+        (func (export "func_0") (result i32)
+         call 0 ;; calls the import, which is func #0
+        )
+    )
+`));
+
+enableGeckoProfiling();
+WasmHelpers.startProfiling();
+setJitCompilerOption("ion.warmup.trigger", 20);
+
+Object.prototype[3] = 3;
+
+var imports = {
+    global: {
+        func: function() {}
+    }
+}
+
+for (let i = 0; i < 100; ++i)  {
+    for (dmod in imports)
+        for (dname in imports[dmod])
+            if (imports[dmod][dname] == undefined) {}
+    instance = new WebAssembly.Instance(lfModule, imports);
+    print(i, instance.exports.func_0());
+}
diff --git a/js/src/jit-test/tests/wasm/regress/ion-error-gc-fakeexitframe.js b/js/src/jit-test/tests/wasm/regress/ion-error-gc-fakeexitframe.js
new file mode 100644
index 0000000000..5b184611d7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/ion-error-gc-fakeexitframe.js
@@ -0,0 +1,81 @@
+var lfLogBuffer = `
+//corefuzz-dcd-endofdata
+for (var i = 0; gczeal(4,10); g(buffer))
+  assertEq(assignParameterGetElement(42), 17);
+//corefuzz-dcd-endofdata
+//corefuzz-dcd-endofdata
+//corefuzz-dcd-endofdata
+g = newGlobal({newCompartment: true});
+g.parent = this
+g.eval("Debugger(parent).onExceptionUnwind=(function(){})")
+`;
+lfLogBuffer = lfLogBuffer.split('\n');
+
+gcPreserveCode();
+
+var letext =`(module
+  (type $type0 (func (param i32 i64)))
+  (type $type1 (func (param i32) (result i64)))
+  (type $type2 (func (result i32)))
+  (memory 1)
+  (export "store" (func $func0))
+  (export "load" (func $func1))
+  (export "assert_0" (func $func2))
+  (func $func0 (param $var0 i32) (param $var1 i64)
+    local.get $var0
+    local.get $var1
+    i64.store16 offset=16
+  )
+  (func $func1 (param $var0 i32) (result i64)
+    local.get $var0
+    i64.load16_s offset=16
+  )
+  (func $func2 (result i32)
+    i32.const 65519
+    i64.const -32768
+    call $func0
+    i32.const 1
+  )
+  (data (i32.const 0)
+    "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\t\\n\\0b\\0c\\0d\\0e\\0f"
+  )
+  (data (i32.const 16)
+    "\\f0\\f1\\f2\\f3\\f4\\f5\\f6\\f7\\f8\\f9\\fa\\fb\\fc\\fd\\fe\\ff"
+  )
+)`;
+
+var binary = wasmTextToBinary(letext);
+var module = new WebAssembly.Module(binary);
+
+var lfCodeBuffer = "";
+while (true) {
+    var line = lfLogBuffer.shift();
+    if (line == null) {
+        break;
+    } else if (line == "//corefuzz-dcd-endofdata") {
+        processCode(lfCodeBuffer);
+    } else {
+        lfCodeBuffer += line + "\n";
+    }
+}
+
+if (lfCodeBuffer) processCode(lfCodeBuffer);
+
+function processCode(code) {
+    evaluate(code);
+    while (true) {
+        imports = {}
+        try {
+            instance = new WebAssembly.Instance(module, imports);
+            break;
+        } catch (exc) {}
+    }
+    for (let descriptor of WebAssembly.Module.exports(module)) {
+        switch (descriptor.kind) {
+            case "function":
+                try {
+                    print(instance.exports[descriptor.name]())
+                } catch (exc1) {}
+        }
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/regress/ion-inlinedcall-resumepoint.js b/js/src/jit-test/tests/wasm/regress/ion-inlinedcall-resumepoint.js
new file mode 100644
index 0000000000..9b9c8209bc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/ion-inlinedcall-resumepoint.js
@@ -0,0 +1,50 @@
+var invalidatedFunction = function() { return false; }
+
+var counter = 0;
+
+function maybeInvalidate(iplusk) {
+    if (iplusk === 0) {
+        // This should happen only once; it will invalidate the call frame of
+        // the ion() function, which should rewind to just after the wasm call
+        // (if it got its own resume point).
+        // Before the patch, the wasm call doesn't get its resume point, so
+        // it's repeated and the importedFunc() is called once too many.
+        counter++;
+        invalidatedFunction = function () { return true; };
+    }
+}
+
+function importedFunc(k) {
+    for (let i = 100; i --> 0 ;) {
+        maybeInvalidate(i + k);
+    }
+}
+
+let { exports } = new WebAssembly.Instance(
+    new WebAssembly.Module(
+        wasmTextToBinary(`
+        (module
+            (func $imp (import "env" "importedFunc") (param i32))
+            (func (export "exp") (param i32)
+                local.get 0
+                call $imp
+            )
+        )
+        `)
+    ), {
+        env: {
+            importedFunc
+        }
+    }
+);
+
+function ion(k) {
+    exports.exp(k);
+    invalidatedFunction();
+}
+
+for (let k = 100; k --> 0 ;) {
+    ion(k);
+}
+
+assertEq(counter, 1);
diff --git a/js/src/jit-test/tests/wasm/regress/ion-lazy-stubs-jit.js b/js/src/jit-test/tests/wasm/regress/ion-lazy-stubs-jit.js
new file mode 100644
index 0000000000..f7592b14fb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/ion-lazy-stubs-jit.js
@@ -0,0 +1,13 @@
+(function coerceinplace() {
+    var { table } = wasmEvalText(`(module
+        (func $add (param i32) (param i32) (result i32)
+         local.get 0
+        )
+        (table (export "table") 10 funcref)
+        (elem (i32.const 0) $add)
+    )`).exports;
+
+    for (var i = 0; i < 100; i++) {
+      table.get(0)((true).get++, i*2+1);
+    }
+})();
diff --git a/js/src/jit-test/tests/wasm/regress/ion-many-results.js b/js/src/jit-test/tests/wasm/regress/ion-many-results.js
new file mode 100644
index 0000000000..bc4df59e20
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/ion-many-results.js
@@ -0,0 +1,17 @@
+// This provokes a crash in ion if its tempalloc reservation logic is not
+// up to snuff, bug 1675844.
+
+for ( let i=100; i < 300; i++ ) {
+    let xs = new Array(i).fill(1);
+
+    // Should not crash the compiler but should fail validation
+    assertErrorMessage(() => new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func $f (result ${xs.map(_ => 'i32 ').join(' ')})
+    ${xs.map((_) => '(i32.const 1)').join(' ')})
+  (func $g
+    (call $f)))`)),
+                       WebAssembly.CompileError,
+                       /(unused values not explicitly dropped)|(values remaining on stack)/);
+
+}
diff --git a/js/src/jit-test/tests/wasm/regress/jit-updatepcquad.js b/js/src/jit-test/tests/wasm/regress/jit-updatepcquad.js
new file mode 100644
index 0000000000..69f9371b84
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/jit-updatepcquad.js
@@ -0,0 +1,31 @@
+var evalInFrame = (function (global) {
+    var dbgGlobal = newGlobal({newCompartment: true});
+    var dbg = new dbgGlobal.Debugger();
+    return function evalInFrame(code) {
+        dbg.addDebuggee(global);
+        var frame = dbg.getNewestFrame().older;
+        frame = frame.older || frame;
+        let completion = frame.eval(code);
+        return completion.return;
+    };
+})(this);
+
+const { exports } = wasmEvalText(`
+    (module
+        (import "global" "func" (func (param i32) (result i32)))
+        (func (export "func_0") (param i32)(result i32)
+         local.get 0
+         call 0
+        )
+    )
+`, {
+    global: {
+        func: function jscode(i) {
+            return evalInFrame(`a = ${i}`);
+        }
+    }
+});
+
+for (i = 0; i < 20; ++i) {
+    assertEq(exports.func_0(i), i);
+}
diff --git a/js/src/jit-test/tests/wasm/regress/lazy-table-nan.js b/js/src/jit-test/tests/wasm/regress/lazy-table-nan.js
new file mode 100644
index 0000000000..aa7bda7485
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/lazy-table-nan.js
@@ -0,0 +1,10 @@
+let i = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (func $f (result f32)
+        f32.const nan:0x42
+    )
+    (table (export "table") 10 funcref)
+    (elem (i32.const 0) $f)
+)
+`))).exports;
+i.table.get(0)();
diff --git a/js/src/jit-test/tests/wasm/regress/load-lane-oob.js b/js/src/jit-test/tests/wasm/regress/load-lane-oob.js
new file mode 100644
index 0000000000..02fea77daf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/load-lane-oob.js
@@ -0,0 +1,14 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Bug 1735128 - useless load should not be eliminated by Ion
+
+var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+`(module
+   (memory 0)
+   (func (export "f") (param i32)
+     (v128.load64_lane 1 (local.get 0) (v128.const i32x4 0 0 0 0))
+     drop))`)));
+assertErrorMessage(() => ins.exports.f(100),
+                   WebAssembly.RuntimeError,
+                   /out of bounds/);
+
diff --git a/js/src/jit-test/tests/wasm/regress/long-select.js b/js/src/jit-test/tests/wasm/regress/long-select.js
new file mode 100644
index 0000000000..dfda4e6799
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/long-select.js
@@ -0,0 +1,38 @@
+// Bug 1337060 causes too much register pressure on x86 by requiring four int64
+// values in registers at the same time.
+
+wasmFullPassI64(`
+(module
+  (func $run (result i64)
+    i64.const 0x2800000033
+    i64.const 0x9900000044
+    i64.const 0x1000000012
+    i64.const 0x1000000013
+    i64.lt_s
+    select))`, "0x2800000033");
+
+wasmFullPassI64(`
+(module
+  (func $run (result i64)
+    i64.const 0x2800000033
+    i64.const 0x9900000044
+    i64.const 0x1000000013
+    i64.const 0x1000000012
+    i64.lt_s
+    select))`, "0x9900000044");
+
+wasmFullPassI64(`
+(module
+    (func $run (param f32) (result i64)
+        i64.const 0x13100000001
+        i64.const 0x23370000002
+        i64.const 0x34480000003
+        i32.const 1
+        select
+        i32.const 1
+        select
+        i64.const 0x45590000004
+        i32.const 1
+        select
+    )
+)`, "0x13100000001", {}, 'f32.const 0');
diff --git a/js/src/jit-test/tests/wasm/regress/misc-control-flow.js b/js/src/jit-test/tests/wasm/regress/misc-control-flow.js
new file mode 100644
index 0000000000..6feafcee1b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/misc-control-flow.js
@@ -0,0 +1,227 @@
+wasmFailValidateText(`(module
+   (func (param i32) (result i32)
+     (loop (if (i32.const 0) (br 0)) (local.get 0)))
+   (export "" (func 0))
+)`, /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+wasmFailValidateText(`(module
+   (func (param i32)
+     (loop (if (i32.const 0) (br 0)) (local.get 0)))
+   (export "" (func 0))
+)`, /(unused values not explicitly dropped by end of block)|(values remaining on stack at end of block)/);
+
+wasmFailValidateText(`(module
+   (func (param i32) (result i32)
+     (loop (if (i32.const 0) (br 0)) (drop (local.get 0))))
+   (export "" (func 0))
+)`, emptyStackError);
+
+assertEq(wasmEvalText(`(module
+   (func (param i32) (result i32)
+     (loop (if (i32.const 0) (br 0))) (local.get 0))
+   (export "" (func 0))
+)`).exports[""](42), 42);
+
+wasmEvalText(`(module (func $func$0
+      (block (if (i32.const 1) (loop (br_table 0 (br 0)))))
+  )
+)`);
+
+wasmEvalText(`(module (func
+      (block $out (loop $in (br_table $out $out $in (i32.const 0))))
+  )
+)`);
+
+wasmEvalText(`(module (func (result i32)
+  (select
+    (block (result i32)
+      (drop (block (result i32)
+        (br_table
+         1
+         0
+         (i32.const 1)
+         (i32.const 0)
+        )
+      ))
+      (i32.const 2)
+    )
+    (i32.const 3)
+    (i32.const 4)
+  )
+))
+`);
+
+wasmEvalText(`(module
+  (func (param i32) (param i32) (result i32) (i32.const 0))
+  (func (result i32)
+   (call 0 (i32.const 1) (call 0 (i32.const 2) (i32.const 3)))
+   (call 0 (unreachable) (i32.const 4))
+  )
+)`);
+
+wasmEvalText(`
+(module
+
+ (func
+  (param i32) (param i32) (param i32) (param i32)
+  (result i32)
+  (i32.const 0)
+ )
+
+ (func (result i32)
+  (call 0
+   (i32.const 42)
+   (i32.const 53)
+   (call 0 (i32.const 100) (i32.const 13) (i32.const 37) (i32.const 128))
+   (return (i32.const 42))
+  )
+ )
+
+ (export "" (func 1))
+)
+`).exports[""]();
+
+wasmEvalText(`
+(module
+    (import "check" "one" (func (param i32)))
+    (import "check" "two" (func (param i32) (param i32)))
+    (func (param i32) (call 0 (local.get 0)))
+    (func (param i32) (param i32) (call 1 (local.get 0) (local.get 1)))
+    (func
+        (call 1
+            (i32.const 43)
+            (block $b (result i32)
+                (if (i32.const 1)
+                    (call 0
+                        (block (result i32)
+                            (call 0 (i32.const 42))
+                            (br $b (i32.const 10)))))
+                (i32.const 44))))
+    (export "foo" (func 4)))
+`, {
+    check: {
+        one(x) {
+            assertEq(x, 42);
+        },
+        two(x, y) {
+            assertEq(x, 43);
+            assertEq(y, 10);
+        }
+    }
+}).exports.foo();
+
+assertEq(wasmEvalText(`(module (func
+ return
+ (select
+  (loop (result i32) (i32.const 1))
+  (loop (result i32) (i32.const 2))
+  (i32.const 3)
+ )
+ drop
+) (export "" (func 0)))`).exports[""](), undefined);
+
+wasmEvalText(`(module (func (result i32)
+ (return (i32.const 0))
+ (select
+  (loop (result i32) (i32.const 1))
+  (loop (result i32) (i32.const 2))
+  (i32.const 3)
+ )
+))`);
+
+wasmEvalText(`(module (func
+ (block $return
+  (block $beforeReturn
+    (block $out
+      (loop $in
+       (block $otherTable
+         (br_table
+          $return
+          $return
+          $otherTable
+          $beforeReturn
+          (i32.const 0)
+         )
+       )
+       (block $backTop
+        (br_table
+         $backTop
+         $backTop
+         $beforeReturn
+         (i32.const 0)
+        )
+       )
+       (br $in)
+      )
+    )
+  )
+ )
+))`);
+
+wasmFailValidateText(
+`(module
+  (func $func$0
+   (select
+    (if (result f32)
+     (i32.const 0)
+     (f32.const 0)
+     (i32.const 0)
+    )
+    (if (result f32)
+     (i32.const 0)
+     (f32.const 0)
+     (i32.const 0)
+    )
+    (i32.const 0)
+   )
+  )
+)`, mismatchError("i32", "f32"));
+
+wasmEvalText(`
+(module
+ (func (result i32)
+  (i32.add
+   (block $outer (result i32)
+    (drop (block $middle (result i32)
+     (block $inner (result i32)
+      (br_table $middle $outer $inner (i32.const 42) (i32.const 1))
+     )
+     (nop)
+    ))
+    (i32.const 0)
+   )
+   (i32.const 13)
+  )
+ )
+)
+`);
+
+wasmFailValidateText(`
+(module
+    (func (result i32)
+      (loop
+        (i32.const 0)
+        (br_table 1 0 (i32.const 15))
+      )
+    )
+)`, /(br_table targets must all have the same arity)|(br_table target labels have different types)/);
+
+wasmFailValidateText(`
+(module
+  (func (result i32)
+    (loop (result i32)
+      (i32.const 0)
+      (br_table 1 0 (i32.const 15))
+    )
+  )
+)`, /(br_table targets must all have the same arity)|(br_table target labels have different types)/);
+
+wasmValidateText(`
+(module
+    (func
+        (loop
+          (i32.const 0)
+          (br_table 1 0 (i32.const 15))
+        )
+    )
+)`);
diff --git a/js/src/jit-test/tests/wasm/regress/movable-traps.js b/js/src/jit-test/tests/wasm/regress/movable-traps.js
new file mode 100644
index 0000000000..ac5577032b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/movable-traps.js
@@ -0,0 +1,38 @@
+let bodies = [
+    `
+    i32.const 1
+    i32.const 0
+    i32.div_s
+    `,
+    `
+    i32.const 1
+    i32.const 0
+    i32.rem_s
+    `,
+    `
+    f64.const 1.7976931348623157e+308
+    i64.trunc_s/f64
+    `,
+    `
+    f32.const 3.40282347e+38
+    i32.trunc_s/f32
+    `
+];
+
+for (let body of bodies) {
+    wasmFullPass(`
+    (module
+        (func $f (param $x i32) (result i32)
+            loop $top (result i32)
+                local.get $x
+                if
+                    local.get $x
+                    br 2
+                end
+                ${body}
+                br $top
+            end
+        )
+        (export "run" (func $f))
+    )`, 42, {}, 42);
+}
diff --git a/js/src/jit-test/tests/wasm/regress/no-directives/debugger-no-script.js b/js/src/jit-test/tests/wasm/regress/no-directives/debugger-no-script.js
new file mode 100644
index 0000000000..1072e9268e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/no-directives/debugger-no-script.js
@@ -0,0 +1,19 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled(); exitstatus:3
+
+function userError() {};
+
+let g = newGlobal({newCompartment: true});
+let dbg = new Debugger(g);
+
+g.eval(`
+  var wasm = wasmTextToBinary('(module (func (export "test") (nop)))');
+  var m = new WebAssembly.Instance(new WebAssembly.Module(wasm));
+`);
+
+dbg.onEnterFrame = function(frame) {
+    if (frame.type == "wasmcall") {
+        throw new userError()
+    }
+}
+
+result = g.eval("m.exports.test()");
diff --git a/js/src/jit-test/tests/wasm/regress/nop-fill-jit-exit.js b/js/src/jit-test/tests/wasm/regress/nop-fill-jit-exit.js
new file mode 100644
index 0000000000..0aadbc22a5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/nop-fill-jit-exit.js
@@ -0,0 +1,28 @@
+// |jit-test| --arm-asm-nop-fill=1
+//
+try {
+    enableSingleStepProfiling();
+    disableSingleStepProfiling();
+} catch (e) {
+    // Early quit on platforms not supporting single step profiling.
+    quit();
+}
+
+load(libdir + "asm.js");
+
+var ffi = function(enable) {
+    enableGeckoProfiling();
+    enableSingleStepProfiling();
+}
+var f = asmLink(asmCompile('global', 'ffis',
+  USE_ASM + `
+    var ffi=ffis.ffi;
+    function f(i) {
+      i=i|0;
+      ffi(i|0);
+    } return f
+  `), null, {
+    ffi
+});
+f(0);
+f(+1);
diff --git a/js/src/jit-test/tests/wasm/regress/null-call.js b/js/src/jit-test/tests/wasm/regress/null-call.js
new file mode 100644
index 0000000000..b7ed4b46e3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/null-call.js
@@ -0,0 +1,14 @@
+// Bug 1747540 - two trap descriptors at the same address led to some confusion.
+
+var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+  (table 1 funcref)
+  (memory 1)
+  (func $test (export "test") (result i32)
+    (call_indirect (i32.const 0))
+    (i32.load (i32.const 0))
+)
+`)))
+assertErrorMessage(() => ins.exports.test(),
+                   WebAssembly.RuntimeError,
+                   /indirect call to null/);
+
diff --git a/js/src/jit-test/tests/wasm/regress/null-metadata-filename.js b/js/src/jit-test/tests/wasm/regress/null-metadata-filename.js
new file mode 100644
index 0000000000..638fef6c40
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/null-metadata-filename.js
@@ -0,0 +1,20 @@
+// |jit-test| skip-if: !isAsmJSCompilationAvailable()
+
+enableGeckoProfiling();
+var code = evaluate("(function() { 'use asm'; function g() { return 43 } return g })", {
+    fileName: null
+});
+
+assertEq(code()(), 43);
+
+evaluate(`
+let f = evalReturningScope.bind(null, '');
+
+(function(glob, stdlib) {
+    "use asm";
+    var f = stdlib.f;
+    function _() { f(); }
+    return _;
+})(this, { f })();
+`, { fileName: null });
+
diff --git a/js/src/jit-test/tests/wasm/regress/onlyjsiter-while-wasm.js b/js/src/jit-test/tests/wasm/regress/onlyjsiter-while-wasm.js
new file mode 100644
index 0000000000..f67b6d27b8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/onlyjsiter-while-wasm.js
@@ -0,0 +1,13 @@
+// |jit-test| skip-if: typeof evalInCooperativeThread === 'undefined'
+
+try {
+    evalInCooperativeThread(`
+        var { f } = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(\`
+        (module
+         (func $f (export "f") call $f)
+        )
+        \`))).exports;
+        gczeal(9);
+        f();
+    `);
+} catch(e) {}
diff --git a/js/src/jit-test/tests/wasm/regress/oom-eval.js b/js/src/jit-test/tests/wasm/regress/oom-eval.js
new file mode 100644
index 0000000000..1ce7c26df1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/oom-eval.js
@@ -0,0 +1,7 @@
+// |jit-test| slow; allow-oom; skip-if: !wasmIsSupported() || !('oomTest' in this)
+
+function foo() {
+  var g = newGlobal({sameZoneAs: this});
+  g.eval(`o = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module (func) (export "" (func 0)))')));`);
+}
+oomTest(foo);
diff --git a/js/src/jit-test/tests/wasm/regress/oom-init.js b/js/src/jit-test/tests/wasm/regress/oom-init.js
new file mode 100644
index 0000000000..f08b088107
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/oom-init.js
@@ -0,0 +1,21 @@
+// |jit-test| slow; allow-oom; skip-if: !wasmIsSupported() || !('oomTest' in this)
+
+Object.getOwnPropertyNames(this);
+s = newGlobal();
+evalcx("\
+    /x/;\
+    oomTest(function() {\
+        this[\"\"];\
+        void 0;\
+        Object.freeze(this);\
+        l(undefined)();\
+        O;\
+        t;\
+        0;\
+        ({e});\
+        i;\
+        0;\
+        ({ z: p ? 0 : 0});\
+        s;\
+    });\
+", s);
diff --git a/js/src/jit-test/tests/wasm/regress/oom-masm-baseline.js b/js/src/jit-test/tests/wasm/regress/oom-masm-baseline.js
new file mode 100644
index 0000000000..cda1b54584
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/oom-masm-baseline.js
@@ -0,0 +1,31 @@
+// |jit-test| slow; skip-if: !('oomTest' in this)
+
+// Test baseline compiler only.
+if (typeof wasmCompileMode === 'undefined' || wasmCompileMode() != 'baseline')
+    quit();
+
+try {
+    var bin = wasmTextToBinary(
+	`(module (func (result i32) (param f64) (param f32)
+                i64.const 0
+                local.get 0
+                drop
+                i32.wrap/i64
+                f64.const 0
+                f64.const 0
+                i32.const 0
+                select
+                f32.const 0
+                f32.const 0
+                f32.const 0
+                i32.const 0
+                select
+                i32.const 0
+                i32.const 0
+                i32.const 0
+                select
+                select
+                drop
+                  drop))`);
+    oomTest(() => new WebAssembly.Module(bin));
+} catch(e) { }
diff --git a/js/src/jit-test/tests/wasm/regress/oom-wasm-streaming.js b/js/src/jit-test/tests/wasm/regress/oom-wasm-streaming.js
new file mode 100644
index 0000000000..5d7e719912
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/oom-wasm-streaming.js
@@ -0,0 +1,14 @@
+// |jit-test| skip-if: !('oomAfterAllocations' in this)
+
+ignoreUnhandledRejections();
+
+try {
+    WebAssembly.compileStreaming();
+} catch (err) {
+    assertEq(String(err).indexOf("not supported with --no-threads") !== -1, true);
+    quit();
+}
+oomAfterAllocations(1, 2);
+var x = wasmTextToBinary('(module (func (export "run") (result i32) i32.const 42))');
+WebAssembly.compileStreaming(x);
+drainJobQueue();
diff --git a/js/src/jit-test/tests/wasm/regress/oom-wasmtexttobinary-block.js b/js/src/jit-test/tests/wasm/regress/oom-wasmtexttobinary-block.js
new file mode 100644
index 0000000000..6f3b666873
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/oom-wasmtexttobinary-block.js
@@ -0,0 +1,7 @@
+// |jit-test| skip-if: !('oomTest' in this)
+
+try {
+    oomTest((function () {
+        wasmTextToBinary("(module(func(loop $label1 $label0)))");
+    }));
+} catch(e) { }
diff --git a/js/src/jit-test/tests/wasm/regress/pass-stack-int64.js b/js/src/jit-test/tests/wasm/regress/pass-stack-int64.js
new file mode 100644
index 0000000000..94497f35de
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/pass-stack-int64.js
@@ -0,0 +1,15 @@
+var params = '';
+var locals = '';
+for (let i = 0; i < 20; i++) {
+    params += '(param i64) ';
+    locals += `(local.get ${i}) `;
+}
+
+wasmEvalText(`
+(module
+    (func
+        ${params}
+        (call 0 ${locals})
+    )
+)
+`);
diff --git a/js/src/jit-test/tests/wasm/regress/proxy-get-trap-table.js b/js/src/jit-test/tests/wasm/regress/proxy-get-trap-table.js
new file mode 100644
index 0000000000..56158e7b15
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/proxy-get-trap-table.js
@@ -0,0 +1,14 @@
+// The 'get' handler should be invoked directly when reading fields of the
+// descriptor.
+
+assertErrorMessage(() => {
+    var desc = {
+        element: "anyfunc",
+        initial: 1
+    };
+    var proxy = new Proxy({}, {
+        get: true
+    });
+    Object.setPrototypeOf(desc, proxy);
+    let table = new WebAssembly.Table(desc);
+}, TypeError, /proxy handler's get trap/);
diff --git a/js/src/jit-test/tests/wasm/regress/regalloc-i64-load-store-global.js b/js/src/jit-test/tests/wasm/regress/regalloc-i64-load-store-global.js
new file mode 100644
index 0000000000..da971d1aa2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/regalloc-i64-load-store-global.js
@@ -0,0 +1,20 @@
+wasmFullPassI64(`
+    (module
+        (global (mut i64) (i64.const 9970292656026947164))
+        (func (export "global.get_0") (result i64) global.get 0)
+
+        (func $run (param i32) (result i64)
+            i64.const 8692897571457488645
+            i64.const 1028567229461950342
+            i64.mul
+            global.get 0
+            f32.const 3.141592653
+            f32.floor
+            f32.const -13.37
+            f32.floor
+            f32.copysign
+            drop
+            i64.div_u
+        )
+    )
+`, 1, {}, 'i32.const 0');
diff --git a/js/src/jit-test/tests/wasm/regress/regalloc-muli64.js b/js/src/jit-test/tests/wasm/regress/regalloc-muli64.js
new file mode 100644
index 0000000000..b9ad31dca9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/regalloc-muli64.js
@@ -0,0 +1,14 @@
+// Bug 1298808.
+assertEq(wasmEvalText(`(module
+    (func
+        (result i32)
+        (i32.wrap/i64
+            (i64.mul
+                ;; Conditions: rhs == lhs, rhs is not a constant.
+                (i64.add (i64.const 1) (i64.const 10))
+                (i64.add (i64.const 1) (i64.const 10))
+            )
+        )
+    )
+    (export "" (func 0))
+)`).exports[""](), 121);
diff --git a/js/src/jit-test/tests/wasm/regress/reserve-enough.js b/js/src/jit-test/tests/wasm/regress/reserve-enough.js
new file mode 100644
index 0000000000..c591fa3153
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/reserve-enough.js
@@ -0,0 +1,13 @@
+// Bug 1281131 - be sure to reserve enough stack space
+
+wasmEvalText(
+`(module
+  (func $func0
+   ${loopy(100)}
+   (nop)))`);
+
+function loopy(n) {
+    if (n == 0)
+	return "(nop)";
+    return `(block $out${n} (loop $in${n} ${loopy(n-1)}))`;
+}
diff --git a/js/src/jit-test/tests/wasm/regress/reserve-joinreg.js b/js/src/jit-test/tests/wasm/regress/reserve-joinreg.js
new file mode 100644
index 0000000000..7121914651
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/reserve-joinreg.js
@@ -0,0 +1,22 @@
+// Bug 1280933, excerpted from binary test case provided there.
+
+wasmEvalText(
+`(module
+  (func $func0 (param $arg0 i32) (result i32) (local $var0 i64)
+  (local.set $var0 (i64.extend_u/i32 (local.get $arg0)))
+  (i32.wrap/i64
+   (i64.add
+    (block (result i64)
+      (block $label1
+        (loop $label0
+          (drop
+            (block $label2 (result i64)
+              (br_table $label2 (i64.const 0) (local.get $arg0))
+            )
+          )
+        (local.set $var0 (i64.mul (i64.const 2) (local.get $var0)))
+      )
+    )
+    (tee_local $var0 (i64.add (i64.const 4) (local.get $var0))))
+    (i64.const 1))))
+  (export "" (func 0)))`);
diff --git a/js/src/jit-test/tests/wasm/regress/savedframe-lookup-in-wasm.js b/js/src/jit-test/tests/wasm/regress/savedframe-lookup-in-wasm.js
new file mode 100644
index 0000000000..6527c78efa
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/savedframe-lookup-in-wasm.js
@@ -0,0 +1,17 @@
+g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval(`(function() {
+  Debugger(parent).onExceptionUnwind = function(frame) { return frame.eval(""); }
+})()`);
+
+var module = new WebAssembly.Module(wasmTextToBinary(`
+  (module (import $imp "" "inc") (func) (func $start (call $imp)) (start $start) (export "" (func $start)))
+`));
+
+var imports = {
+    "": {
+        inc: function() { undefined_function(); }
+    }
+};
+
+new WebAssembly.Instance(module, imports).exports['']();
diff --git a/js/src/jit-test/tests/wasm/regress/select-any.js b/js/src/jit-test/tests/wasm/regress/select-any.js
new file mode 100644
index 0000000000..9e85d33897
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/select-any.js
@@ -0,0 +1,41 @@
+// Bug 1280921
+
+var m1 = wasmEvalText(
+`(module
+  (type $type0 (func))
+  (func $func0
+   (select
+     (unreachable)
+     (return (nop))
+     (loop (result i32) (i32.const 1))
+   )
+   drop
+  )
+  (export "" (func 0)))`).exports[""];
+
+try {
+    m1();
+} catch (e) {
+    if (!(e instanceof Error && e.message.match(/unreachable executed/)))
+	throw e;
+}
+
+var m2 = wasmEvalText(
+`(module
+  (type $type0 (func))
+  (func $func0
+   (select
+    (i32.const 26)
+    (unreachable)
+    (i32.const 3)
+   )
+   drop
+  )
+  (export "" (func 0)))`).exports[""];
+
+try {
+    m2();
+} catch (e) {
+    if (!(e instanceof Error && e.message.match(/unreachable executed/)))
+	throw e;
+}
diff --git a/js/src/jit-test/tests/wasm/regress/shift-counts.js b/js/src/jit-test/tests/wasm/regress/shift-counts.js
new file mode 100644
index 0000000000..aadc9e5d76
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/shift-counts.js
@@ -0,0 +1,8 @@
+// Bug 1280926, extracted from binary
+
+wasmEvalText(
+`(module
+  (type $type0 (func (result i32)))
+  (export "" (func $func0))
+  (func $func0 (result i32)
+   (i32.shr_s (i32.const -40) (i32.const 34))))`);
diff --git a/js/src/jit-test/tests/wasm/regress/signed-unsigned-div-mod.js b/js/src/jit-test/tests/wasm/regress/signed-unsigned-div-mod.js
new file mode 100644
index 0000000000..370676d2c4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/signed-unsigned-div-mod.js
@@ -0,0 +1,75 @@
+// The result should be -1 because it is (i32.rem_s -1 10000) and the spec
+// stipulates "result has the sign of the dividend".  This test uncovers a bug
+// in SpiderMonkey wherein the shape of the lhs (it looks like an unsigned
+// value) causes an unsigned modulo to be emitted.
+
+assertEq(wasmEvalText(
+    `(module
+      (func (result i32)
+       (i32.const -1)
+       (i32.const 0)
+       i32.shr_u
+       (i32.const 10000)
+       i32.rem_s)
+      (export "f" (func 0)))`).exports.f(), -1);
+
+// Ditto for int64
+
+wasmAssert(
+    `(module
+      (func $run (result i64)
+       (i64.const -1)
+       (i64.const 0)
+       i64.shr_u
+       (i64.const 10000)
+       i64.rem_s)
+     )`, [{type:'i64', expected:'0xffffffffffffffff', func:'$run'}]);
+
+// Despite the signed shift this is 0x80000000 % 10000 (rem_u)
+// and the result is positive.
+
+assertEq(wasmEvalText(
+    `(module
+      (func (result i32)
+       (i32.const -1)
+       (i32.const 0)
+       i32.shl
+       (i32.const 10000)
+       i32.rem_u)
+      (export "f" (func 0)))`).exports.f(), 7295);
+
+// 0x80000000 is really -0x80000000 so the result of signed division shall be
+// negative.
+
+assertEq(wasmEvalText(
+    `(module
+      (func (result i32)
+       (i32.const 0x80000000)
+       (i32.const 0)
+       i32.shr_u
+       (i32.const 10000)
+       i32.div_s)
+      (export "f" (func 0)))`).exports.f(), -214748);
+
+assertEq(wasmEvalText(
+    `(module
+      (func (result i32)
+       (i32.const 0x80000000)
+       (i32.const 0)
+       i32.shr_u
+       (i32.const -10000)
+       i32.div_s)
+      (export "f" (func 0)))`).exports.f(), 214748);
+
+// And the result of unsigned division shall be positive.
+
+assertEq(wasmEvalText(
+    `(module
+      (func (result i32)
+       (i32.const 0x80000000)
+       (i32.const 0)
+       i32.shr_u
+       (i32.const 10000)
+       i32.div_u)
+      (export "f" (func 0)))`).exports.f(), 214748);
+
diff --git a/js/src/jit-test/tests/wasm/regress/startfunc-in-table.js b/js/src/jit-test/tests/wasm/regress/startfunc-in-table.js
new file mode 100644
index 0000000000..12ebfe64ab
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/startfunc-in-table.js
@@ -0,0 +1,6 @@
+wasmEvalText(`(module
+    (func)
+    (start 0)
+    (table $0 1 anyfunc)
+    (elem 0 (i32.const 0) func 0)
+)`);
diff --git a/js/src/jit-test/tests/wasm/regress/table-of-anyref.js b/js/src/jit-test/tests/wasm/regress/table-of-anyref.js
new file mode 100644
index 0000000000..a19ec95be5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/table-of-anyref.js
@@ -0,0 +1,9 @@
+// Faulty prebarrier for tables.
+gczeal(4, 8);
+let ins = wasmEvalText(
+    `(module
+       (table (export "t") 10 externref)
+       (func (export "set_externref") (param i32) (param externref)
+         (table.set (get_local 0) (get_local 1))))`);
+ins.exports.set_externref(3, {});
+ins.exports.set_externref(3, null);
diff --git a/js/src/jit-test/tests/wasm/regress/teavm-bugs.js b/js/src/jit-test/tests/wasm/regress/teavm-bugs.js
new file mode 100644
index 0000000000..c526dbd7bb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/teavm-bugs.js
@@ -0,0 +1,53 @@
+// Register allocation issue with LCompareI64AndBranch.
+let params = '';
+let locals = '';
+let tests = '(i64.const 0)';
+
+for (let i = 15; i --> 0;) {
+    params += `\n(param i64)`;
+    locals += `\n(local i64)`;
+    tests = `
+    (if (result i64)
+        (i64.eq
+            (local.get ${i + 8})
+            (local.get ${i})
+        )
+        (local.get ${i + 8})
+        ${tests}
+    )`;
+}
+
+let code = `(module
+   (func $i64
+     ${params} (result i64) ${locals}
+     ${tests}
+   )
+)`
+
+wasmEvalText(code);
+
+// Bounds check elimination.
+assertEq(wasmEvalText(`(module
+    (memory 1)
+    (func (param $p i32) (result i32) (local $l i32)
+        (local.set $l (i32.const 0))
+        (if
+            (local.get $p)
+            (local.set $l
+               (i32.add
+                  (local.get $l)
+                  (i32.load8_s (local.get $p))
+               )
+            )
+        )
+        (local.set $l
+           (i32.add
+              (local.get $l)
+              (i32.load8_s (local.get $p))
+           )
+        )
+        (local.get $l)
+    )
+    (data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f")
+    (export "test" (func 0))
+)`).exports["test"](3), 6);
diff --git a/js/src/jit-test/tests/wasm/regress/too-large-frame.js b/js/src/jit-test/tests/wasm/regress/too-large-frame.js
new file mode 100644
index 0000000000..b91f8f6381
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/too-large-frame.js
@@ -0,0 +1,27 @@
+// Bug 1280934, equivalent test case.
+
+try {
+
+wasmEvalText(
+`(module
+  (func $func0 (result i32) ${locals()}
+   (i32.const 0))
+  (export "" (func 0)))`);
+
+} catch (e) {
+    // The wasm baseline compiler throws OOM on too-large frames, so
+    // handle that.
+    if (!String(e).match(/out of memory/))
+        throw e;
+}
+
+// The wasm baseline compiler cuts off frames at 256KB at the moment;
+// the test case for bug 1280934 constructed a frame around 512KB so
+// duplicate that here.
+
+function locals() {
+    var s = "";
+    for ( var i=0 ; i < 50000 ; i++ )
+        s += "(local f64)\n";
+    return s;
+}
diff --git a/js/src/jit-test/tests/wasm/regress/unaligned-store64.js b/js/src/jit-test/tests/wasm/regress/unaligned-store64.js
new file mode 100644
index 0000000000..b878093451
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/unaligned-store64.js
@@ -0,0 +1,35 @@
+var ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(
+    `(module
+       (memory (export "mem") 1 1)
+       (func (export "store_32_1") (param $ptr i32)
+         (i64.store32 align=1 (local.get $ptr) (i64.const 0xabba1337)))
+       (func (export "store_32_2") (param $ptr i32)
+         (i64.store32 align=2 (local.get $ptr) (i64.const 0xabba1337)))
+       (func (export "store_16") (param $ptr i32)
+         (i64.store16 align=1 (local.get $ptr) (i64.const 0x1337))))`))).exports;
+
+var mem = new Uint8Array(ins.mem.buffer);
+
+ins.store_16(1);
+assertEq(mem[1], 0x37);
+assertEq(mem[2], 0x13);
+
+ins.store_32_1(11);
+assertEq(mem[11], 0x37);
+assertEq(mem[12], 0x13);
+assertEq(mem[13], 0xba);
+assertEq(mem[14], 0xab);
+
+ins.store_32_2(18);
+assertEq(mem[18], 0x37);
+assertEq(mem[19], 0x13);
+assertEq(mem[20], 0xba);
+assertEq(mem[21], 0xab);
+
+// This must also work on all platforms even though we're lying about the
+// alignment.
+ins.store_32_2(29);
+assertEq(mem[29], 0x37);
+assertEq(mem[30], 0x13);
+assertEq(mem[31], 0xba);
+assertEq(mem[32], 0xab);
diff --git a/js/src/jit-test/tests/wasm/regress/upper-maximum-memory.js b/js/src/jit-test/tests/wasm/regress/upper-maximum-memory.js
new file mode 100644
index 0000000000..d2d099f4fe
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/regress/upper-maximum-memory.js
@@ -0,0 +1,4 @@
+new WebAssembly.Memory({
+    initial: 1,
+    maximum: 65536
+});
diff --git a/js/src/jit-test/tests/wasm/resizing.js b/js/src/jit-test/tests/wasm/resizing.js
new file mode 100644
index 0000000000..3142b21721
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/resizing.js
@@ -0,0 +1,235 @@
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const Table = WebAssembly.Table;
+const Memory = WebAssembly.Memory;
+const RuntimeError = WebAssembly.RuntimeError;
+
+// ======
+// MEMORY
+// ======
+
+// Test for stale heap pointers after resize
+
+// Grow directly from builtin call:
+wasmFullPass(`(module
+    (memory 1)
+    (func $test (result i32)
+        (i32.store (i32.const 0) (i32.const 1))
+        (i32.store (i32.const 65532) (i32.const 10))
+        (drop (memory.grow (i32.const 99)))
+        (i32.store (i32.const 6553596) (i32.const 100))
+        (i32.add
+            (i32.load (i32.const 0))
+            (i32.add
+                (i32.load (i32.const 65532))
+                (i32.load (i32.const 6553596)))))
+    (export "run" (func $test))
+)`, 111);
+
+// Grow during import call:
+var exports = wasmEvalText(`(module
+    (import "" "imp" (func $imp))
+    (memory 1)
+    (func $grow (drop (memory.grow (i32.const 99))))
+    (export "grow" (func $grow))
+    (func $test (result i32)
+        (i32.store (i32.const 0) (i32.const 1))
+        (i32.store (i32.const 65532) (i32.const 10))
+        (call $imp)
+        (i32.store (i32.const 6553596) (i32.const 100))
+        (i32.add
+            (i32.load (i32.const 0))
+            (i32.add
+                (i32.load (i32.const 65532))
+                (i32.load (i32.const 6553596)))))
+    (export "test" (func $test))
+)`, {"":{imp() { exports.grow() }}}).exports;
+
+setJitCompilerOption("baseline.warmup.trigger", 2);
+setJitCompilerOption("ion.warmup.trigger", 4);
+for (var i = 0; i < 10; i++)
+    assertEq(exports.test(), 111);
+
+// Grow during call_indirect:
+var mem = new Memory({initial:1});
+var tbl = new Table({initial:1, element:"anyfunc"});
+var exports1 = wasmEvalText(`(module
+    (import "" "mem" (memory 1))
+    (func $grow
+        (i32.store (i32.const 65532) (i32.const 10))
+        (drop (memory.grow (i32.const 99)))
+        (i32.store (i32.const 6553596) (i32.const 100)))
+    (export "grow" (func $grow))
+)`, {"":{mem}}).exports;
+var exports2 = wasmEvalText(`(module
+    (import "" "tbl" (table 1 funcref))
+    (import "" "mem" (memory 1))
+    (type $v2v (func))
+    (func $test (result i32)
+        (i32.store (i32.const 0) (i32.const 1))
+        (call_indirect (type $v2v) (i32.const 0))
+        (i32.add
+            (i32.load (i32.const 0))
+            (i32.add
+                (i32.load (i32.const 65532))
+                (i32.load (i32.const 6553596)))))
+    (export "test" (func $test))
+)`, {"":{tbl, mem}}).exports;
+tbl.set(0, exports1.grow);
+assertEq(exports2.test(), 111);
+
+// Test for coherent length/contents
+
+var mem = new Memory({initial:1});
+new Int32Array(mem.buffer)[0] = 42;
+var mod = new Module(wasmTextToBinary(`(module
+    (import "" "mem" (memory 1))
+    (func $gm (param i32) (result i32) (memory.grow (local.get 0)))
+    (export "grow_memory" (func $gm))
+    (func $cm (result i32) (memory.size))
+    (export "current_memory" (func $cm))
+    (func $ld (param i32) (result i32) (i32.load (local.get 0)))
+    (export "load" (func $ld))
+    (func $st (param i32) (param i32) (i32.store (local.get 0) (local.get 1)))
+    (export "store" (func $st))
+)`));
+var exp1 = new Instance(mod, {"":{mem}}).exports;
+var exp2 = new Instance(mod, {"":{mem}}).exports;
+assertEq(exp1.current_memory(), 1);
+assertEq(exp1.load(0), 42);
+assertEq(exp2.current_memory(), 1);
+assertEq(exp2.load(0), 42);
+mem.grow(1);
+assertEq(mem.buffer.byteLength, 2*64*1024);
+new Int32Array(mem.buffer)[64*1024/4] = 13;
+assertEq(exp1.current_memory(), 2);
+assertEq(exp1.load(0), 42);
+assertEq(exp1.load(64*1024), 13);
+assertEq(exp2.current_memory(), 2);
+assertEq(exp2.load(0), 42);
+assertEq(exp2.load(64*1024), 13);
+exp1.grow_memory(2);
+assertEq(exp1.current_memory(), 4);
+exp1.store(3*64*1024, 99);
+assertEq(exp2.current_memory(), 4);
+assertEq(exp2.load(3*64*1024), 99);
+assertEq(mem.buffer.byteLength, 4*64*1024);
+assertEq(new Int32Array(mem.buffer)[3*64*1024/4], 99);
+
+// Fail at maximum
+
+var mem = new Memory({initial:1, maximum:2});
+assertEq(mem.buffer.byteLength, 1 * 64*1024);
+assertEq(mem.grow(1), 1);
+assertEq(mem.buffer.byteLength, 2 * 64*1024);
+assertErrorMessage(() => mem.grow(1), RangeError, /failed to grow memory/);
+assertEq(mem.buffer.byteLength, 2 * 64*1024);
+
+// Do not misinterpret the maximum @ max for the current size.
+
+(new WebAssembly.Memory({initial: 1, maximum: 65536})).grow(1)
+
+// ======
+// TABLE
+// ======
+
+// Test for stale table base pointers after resize
+
+// Grow during import call:
+var exports = wasmEvalText(`(module
+    (type $v2i (func (result i32)))
+    (import "" "grow" (func $grow))
+    (table (export "tbl") 1 funcref)
+    (func $test (result i32)
+        (i32.add
+            (call_indirect (type $v2i) (i32.const 0))
+            (block (result i32)
+                (call $grow)
+                (call_indirect (type $v2i) (i32.const 1)))))
+    (func $one (result i32) (i32.const 1))
+    (elem (i32.const 0) $one)
+    (func $two (result i32) (i32.const 2))
+    (export "test" (func $test))
+    (export "two" (func $two))
+)`, {"":{grow() { exports.tbl.grow(1); exports.tbl.set(1, exports.two) }}}).exports;
+
+setJitCompilerOption("baseline.warmup.trigger", 2);
+setJitCompilerOption("ion.warmup.trigger", 4);
+for (var i = 0; i < 10; i++)
+    assertEq(exports.test(), 3);
+assertEq(exports.tbl.length, 11);
+
+// Grow during call_indirect:
+var exports1 = wasmEvalText(`(module
+    (import "" "grow" (func $grow))
+    (func $exp (call $grow))
+    (export "exp" (func $exp))
+)`, {"":{grow() { exports2.tbl.grow(1); exports2.tbl.set(2, exports2.eleven) }}}).exports;
+var exports2 = wasmEvalText(`(module
+    (type $v2v (func))
+    (type $v2i (func (result i32)))
+    (import "" "imp" (func $imp))
+    (elem (i32.const 0) $imp)
+    (table 2 funcref)
+    (func $test (result i32)
+        (i32.add
+            (call_indirect (type $v2i) (i32.const 1))
+            (block (result i32)
+                (call_indirect (type $v2v) (i32.const 0))
+                (call_indirect (type $v2i) (i32.const 2)))))
+    (func $ten (result i32) (i32.const 10))
+    (elem (i32.const 1) $ten)
+    (func $eleven (result i32) (i32.const 11))
+    (export "tbl" (table 0))
+    (export "test" (func $test))
+    (export "eleven" (func $eleven))
+)`, {"":{imp:exports1.exp}}).exports;
+assertEq(exports2.test(), 21);
+
+// Test for coherent length/contents
+
+var src = wasmEvalText(`(module
+    (func $one (result i32) (i32.const 1))
+    (export "one" (func $one))
+    (func $two (result i32) (i32.const 2))
+    (export "two" (func $two))
+    (func $three (result i32) (i32.const 3))
+    (export "three" (func $three))
+)`).exports;
+var tbl = new Table({element:"anyfunc", initial:1});
+tbl.set(0, src.one);
+
+var mod = new Module(wasmTextToBinary(`(module
+    (type $v2i (func (result i32)))
+    (table (import "" "tbl") 1 funcref)
+    (func $ci (param i32) (result i32) (call_indirect (type $v2i) (local.get 0)))
+    (export "call_indirect" (func $ci))
+)`));
+var exp1 = new Instance(mod, {"":{tbl}}).exports;
+var exp2 = new Instance(mod, {"":{tbl}}).exports;
+assertEq(exp1.call_indirect(0), 1);
+assertErrorMessage(() => exp1.call_indirect(1), RuntimeError, /index out of bounds/);
+assertEq(exp2.call_indirect(0), 1);
+assertErrorMessage(() => exp2.call_indirect(1), RuntimeError, /index out of bounds/);
+assertEq(tbl.grow(1), 1);
+assertEq(tbl.length, 2);
+assertEq(exp1.call_indirect(0), 1);
+assertErrorMessage(() => exp1.call_indirect(1), Error, /indirect call to null/);
+tbl.set(1, src.two);
+assertEq(exp1.call_indirect(1), 2);
+assertErrorMessage(() => exp1.call_indirect(2), RuntimeError, /index out of bounds/);
+assertEq(tbl.grow(2), 2);
+assertEq(tbl.length, 4);
+assertEq(exp2.call_indirect(0), 1);
+assertEq(exp2.call_indirect(1), 2);
+assertErrorMessage(() => exp2.call_indirect(2), Error, /indirect call to null/);
+assertErrorMessage(() => exp2.call_indirect(3), Error, /indirect call to null/);
+
+// Fail at maximum
+
+var tbl = new Table({initial:1, maximum:2, element:"anyfunc"});
+assertEq(tbl.length, 1);
+assertEq(tbl.grow(1), 1);
+assertEq(tbl.length, 2);
+assertErrorMessage(() => tbl.grow(1), RangeError, /failed to grow table/);
+assertEq(tbl.length, 2);
diff --git a/js/src/jit-test/tests/wasm/select-int32.js b/js/src/jit-test/tests/wasm/select-int32.js
new file mode 100644
index 0000000000..2645b76a44
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/select-int32.js
@@ -0,0 +1,123 @@
+
+// Checks that optimised handling, via Ion, of select-of-I32-values as driven
+// by comparison-of-I32-values, works correctly.  See bug 1532286 comment 7.
+
+function moduleText(cmp_kind /* "eq", "ne", "le_u" etc */)
+{
+  return `(module
+          (func (export "cmpI32_selI32")
+              (param i32) (param i32) (param i32) (param i32)
+              (result i32)
+              (select (get_local 2)
+                      (get_local 3)
+                      (i32.${cmp_kind} (get_local 0) (get_local 1))
+              )
+          ))`;
+}
+
+// Make sure both endpoints and the middlepoint are covered, with one value
+// either side, so as to expose both signedness and off-by-one failures.
+// Ditto quarter points for good measure.
+const vals = [0x0, 0x1,
+              0x3fffffff, 0x40000000, 0x40000001,
+              0x7fffffff, 0x80000000, 0x80000001,
+              0xbfffffff, 0xC0000000, 0xC0000001,
+              0xfffffffe, 0xffffffff];
+
+const testNames
+      = ["eq", "ne", "lt_s", "lt_u", "gt_s", "gt_u",
+                     "le_s", "le_u", "ge_s", "ge_u"];
+
+const expected_eq
+      = [0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,
+         1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,
+         0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,
+         1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,
+         0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0];
+
+const expected_ne
+      = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+         0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+         1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
+         0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+         1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1];
+
+const expected_lt_s
+      = [1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,
+         1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,
+         1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,
+         0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,
+         1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1];
+
+const expected_lt_u
+      = [1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,
+         0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,
+         1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,
+         1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,
+         1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1];
+
+const expected_gt_s
+      = [1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,
+         0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,
+         1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,
+         1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,
+         1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1];
+
+const expected_gt_u
+      = [1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,
+         1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
+         1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,
+         0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
+         1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1];
+
+const expected_le_s
+      = [0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,
+         1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,
+         0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
+         0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,
+         0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0];
+
+const expected_le_u
+      = [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,
+         0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
+         0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,
+         1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
+         0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0];
+
+const expected_ge_s
+      = [0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,
+         0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
+         0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,
+         1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,
+         0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0];
+
+const expected_ge_u
+      = [0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,
+         1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,
+         0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,
+         0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,
+         0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0];
+
+const testExpVecs
+      = [expected_eq, expected_ne,
+         expected_lt_s, expected_lt_u, expected_gt_s, expected_gt_u,
+         expected_le_s, expected_le_u, expected_ge_s, expected_ge_u]
+
+assertEq(testNames.length, testExpVecs.length);
+
+for (i in testNames) {
+    const testExp = testExpVecs[i];
+    assertEq(testExp.length, vals.length * vals.length);
+
+    const inst = wasmEvalText(moduleText(testNames[i]));
+
+    let ctr = 0;
+    for (let a of vals) {
+        for (let b of vals) {
+            const actual = inst.exports.cmpI32_selI32(a, b, 42, 1337);
+            const expected = testExp[ctr] == 0 ? 42 : 1337;
+            assertEq(expected, actual);
+            ctr++;
+        }
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/select.js b/js/src/jit-test/tests/wasm/select.js
new file mode 100644
index 0000000000..e546a8ff63
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/select.js
@@ -0,0 +1,260 @@
+// Test the select instruction
+
+wasmFailValidateText('(module (func (select (i32.const 0) (i32.const 0) (f32.const 0))))', mismatchError("f32", "i32"));
+
+wasmFailValidateText('(module (func (select (i32.const 0) (f32.const 0) (i32.const 0))) (export "" (func 0)))', /(select operand types must match)|(type mismatch: expected f32, found i32)/);
+wasmFailValidateText('(module (func (select (block ) (i32.const 0) (i32.const 0))) (export "" (func 0)))', emptyStackError);
+wasmFailValidateText('(module (func (select (return) (i32.const 0) (i32.const 0))) (export "" (func 0)))', unusedValuesError);
+assertEq(wasmEvalText('(module (func (drop (select (return) (i32.const 0) (i32.const 0)))) (export "" (func 0)))').exports[""](), undefined);
+assertEq(wasmEvalText('(module (func (result i32) (i32.add (i32.const 0) (select (return (i32.const 42)) (i32.const 0) (i32.const 0)))) (export "" (func 0)))').exports[""](), 42);
+wasmFailValidateText('(module (func (select (if (result i32) (i32.const 1) (i32.const 0) (f32.const 0)) (i32.const 0) (i32.const 0))) (export "" (func 0)))', mismatchError("f32", "i32"));
+wasmFailValidateText('(module (func) (func (select (call 0) (call 0) (i32.const 0))) (export "" (func 0)))', emptyStackError);
+
+(function testSideEffects() {
+
+var numT = 0;
+var numF = 0;
+
+var imports = {"": {
+    ifTrue: () => 1 + numT++,
+    ifFalse: () => -1 + numF++,
+}}
+
+// Test that side-effects are applied on both branches.
+var f = wasmEvalText(`
+(module
+ (import "" "ifTrue" (func (result i32)))
+ (import "" "ifFalse" (func (result i32)))
+ (func (param i32) (result i32)
+  (select
+   (call 0)
+   (call 1)
+   (local.get 0)
+  )
+ )
+ (export "" (func 2))
+)
+`, imports).exports[""];
+
+assertEq(f(-1), numT);
+assertEq(numT, 1);
+assertEq(numF, 1);
+
+assertEq(f(0), numF - 2);
+assertEq(numT, 2);
+assertEq(numF, 2);
+
+assertEq(f(1), numT);
+assertEq(numT, 3);
+assertEq(numF, 3);
+
+assertEq(f(0), numF - 2);
+assertEq(numT, 4);
+assertEq(numF, 4);
+
+assertEq(f(0), numF - 2);
+assertEq(numT, 5);
+assertEq(numF, 5);
+
+assertEq(f(1), numT);
+assertEq(numT, 6);
+assertEq(numF, 6);
+
+})();
+
+function testNumSelect(type, trueVal, falseVal) {
+    var trueJS = jsify(trueVal);
+    var falseJS = jsify(falseVal);
+
+    // Always true condition
+    var alwaysTrue = wasmEvalText(`
+    (module
+     (func (param i32) (result ${type})
+      (select
+       (${type}.const ${trueVal})
+       (${type}.const ${falseVal})
+       (i32.const 1)
+      )
+     )
+     (export "" (func 0))
+    )
+    `, {}).exports[""];
+
+    assertEq(alwaysTrue(0), trueJS);
+    assertEq(alwaysTrue(1), trueJS);
+    assertEq(alwaysTrue(-1), trueJS);
+
+    // Always false condition
+    var alwaysFalse = wasmEvalText(`
+    (module
+     (func (param i32) (result ${type})
+      (select
+       (${type}.const ${trueVal})
+       (${type}.const ${falseVal})
+       (i32.const 0)
+      )
+     )
+     (export "" (func 0))
+    )
+    `, {}).exports[""];
+
+    assertEq(alwaysFalse(0), falseJS);
+    assertEq(alwaysFalse(1), falseJS);
+    assertEq(alwaysFalse(-1), falseJS);
+
+    // Variable condition
+    var f = wasmEvalText(`
+    (module
+     (func (param i32) (result ${type})
+      (select
+       (${type}.const ${trueVal})
+       (${type}.const ${falseVal})
+       (local.get 0)
+      )
+     )
+     (export "" (func 0))
+    )
+    `, {}).exports[""];
+
+    assertEq(f(0), falseJS);
+    assertEq(f(1), trueJS);
+    assertEq(f(-1), trueJS);
+
+    wasmFullPass(`
+    (module
+     (func (param i32) (result ${type})
+      (select
+       (${type}.const ${trueVal})
+       (${type}.const ${falseVal})
+       (local.get 0)
+      )
+     )
+     (export "run" (func 0))
+    )`,
+    trueJS,
+    {},
+    1);
+}
+
+testNumSelect('i32', 13, 37);
+testNumSelect('i32', Math.pow(2, 31) - 1, -Math.pow(2, 31));
+
+testNumSelect('f32', Math.fround(13.37), Math.fround(19.89));
+testNumSelect('f32', 'inf', '-0');
+testNumSelect('f32', 'nan', Math.pow(2, -31));
+
+testNumSelect('f64', 13.37, 19.89);
+testNumSelect('f64', 'inf', '-0');
+testNumSelect('f64', 'nan', Math.pow(2, -31));
+
+wasmAssert(`
+(module
+ (func $f (param i32) (result i64)
+  (select
+   (i64.const 0xc0010ff08badf00d)
+   (i64.const 0x12345678deadc0de)
+   (local.get 0)
+  )
+ )
+ (export "" (func 0))
+)`, [
+    { type: 'i64', func: '$f', args: ['i32.const  0'], expected: '0x12345678deadc0de' },
+    { type: 'i64', func: '$f', args: ['i32.const  1'], expected: '0xc0010ff08badf00d' },
+    { type: 'i64', func: '$f', args: ['i32.const -1'], expected: '0xc0010ff08badf00d' },
+], {});
+
+wasmFailValidateText(`(module
+    (func (param externref)
+      (select (local.get 0) (local.get 0) (i32.const 0))
+      drop
+    ))`,
+    /(untyped select)|(type mismatch: select only takes integral types)/);
+
+wasmFailValidateText(`(module
+    (func (param funcref)
+      (select (local.get 0) (local.get 0) (i32.const 0))
+      drop
+    ))`,
+    /(untyped select)|(type mismatch: select only takes integral types)/);
+
+function testRefSelect(type, trueVal, falseVal) {
+    // Always true condition
+    var alwaysTrue = wasmEvalText(`
+    (module
+     (func (param i32 ${type} ${type}) (result ${type})
+      (select (result ${type})
+       local.get 1
+       local.get 2
+       (i32.const 1)
+      )
+     )
+     (export "" (func 0))
+    )
+    `, {}).exports[""];
+
+    assertEq(alwaysTrue(0, trueVal, falseVal), trueVal);
+    assertEq(alwaysTrue(1, trueVal, falseVal), trueVal);
+    assertEq(alwaysTrue(-1, trueVal, falseVal), trueVal);
+
+    // Always false condition
+    var alwaysFalse = wasmEvalText(`
+    (module
+     (func (param i32 ${type} ${type}) (result ${type})
+      (select (result ${type})
+       local.get 1
+       local.get 2
+       (i32.const 0)
+      )
+     )
+     (export "" (func 0))
+    )
+    `, {}).exports[""];
+
+    assertEq(alwaysFalse(0, trueVal, falseVal), falseVal);
+    assertEq(alwaysFalse(1, trueVal, falseVal), falseVal);
+    assertEq(alwaysFalse(-1, trueVal, falseVal), falseVal);
+
+    // Variable condition
+    var f = wasmEvalText(`
+    (module
+     (func (param i32 ${type} ${type}) (result ${type})
+      (select (result ${type})
+        local.get 1
+        local.get 2
+       (local.get 0)
+      )
+     )
+     (export "" (func 0))
+    )
+    `, {}).exports[""];
+
+    assertEq(f(0, trueVal, falseVal), falseVal);
+    assertEq(f(1, trueVal, falseVal), trueVal);
+    assertEq(f(-1, trueVal, falseVal), trueVal);
+
+    wasmFullPass(`
+    (module
+     (func (param i32 ${type} ${type}) (result ${type})
+      (select (result ${type})
+       local.get 1
+       local.get 2
+       (local.get 0)
+      )
+     )
+     (export "run" (func 0))
+    )`,
+    trueVal,
+    {},
+    1,
+    trueVal,
+    falseVal);
+}
+
+testRefSelect('externref', {}, {});
+
+let {export1, export2} = wasmEvalText(`(module
+    (func (export "export1"))
+    (func (export "export2"))
+)`).exports;
+
+testRefSelect('funcref', export1, export2);
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-binop-preamble.js b/js/src/jit-test/tests/wasm/simd/ad-hack-binop-preamble.js
new file mode 100644
index 0000000000..dd1443a1e7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-binop-preamble.js
@@ -0,0 +1,334 @@
+// |jit-test| skip-if: true
+
+// Common code to test simple binary operators.  See runSimpleBinopTest below.
+
+function expandConstantBinopInputs(op, memtype, inputs) {
+    let s = '';
+    let ident = 0;
+    for ( let [a, b] of inputs ) {
+        let constlhs = `${memtype.layoutName} ${a.map(jsValueToWasmName).join(' ')}`;
+        let constrhs = `${memtype.layoutName} ${b.map(jsValueToWasmName).join(' ')}`;
+        s += `
+    ;; lhs is constant, rhs is variable
+    (func (export "run_constlhs${ident}")
+      (v128.store (i32.const 0)
+        (call $doit_constlhs${ident} (v128.const ${constrhs}))))
+    (func $doit_constlhs${ident} (param $b v128) (result v128)
+      (${op} (v128.const ${constlhs}) (local.get $b)))
+
+    ;; rhs is constant, lhs is variable
+    (func (export "run_constrhs${ident}")
+      (v128.store (i32.const 0)
+        (call $doit_constrhs${ident} (v128.const ${constlhs}))))
+    (func $doit_constrhs${ident} (param $a v128) (result v128)
+      (${op} (local.get $a) (v128.const ${constrhs})))
+
+    ;; both operands are constant
+    (func (export "run_constboth${ident}")
+      (v128.store (i32.const 0)
+        (call $doit_constboth${ident})))
+    (func $doit_constboth${ident} (result v128)
+      (${op} (v128.const ${constlhs}) (v128.const ${constrhs})))`
+        ident++;
+    }
+    return s;
+}
+
+function insAndMemBinop(op, memtype, resultmemtype, inputs) {
+    var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+
+    ;; both arguments are variable
+    (func (export "run")
+      (v128.store (i32.const 0)
+        (call $doit (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+    (func $doit (param $a v128) (param $b v128) (result v128)
+      (${op} (local.get $a) (local.get $b)))
+
+    ${expandConstantBinopInputs(op, memtype, inputs)})`);
+    var mem = new memtype(ins.exports.mem.buffer);
+    var resultmem = !resultmemtype || memtype == resultmemtype ? mem : new resultmemtype(ins.exports.mem.buffer);
+    return [ins, mem, resultmem];
+}
+
+function add(bits) { return (x, y) => sign_extend(x+y, bits) }
+function add64(x, y) { return sign_extend(BigInt(x)+BigInt(y), 64) }
+function sub(bits) { return (x, y) => sign_extend(x-y, bits) }
+function sub64(x, y) { return sign_extend(BigInt(x)-BigInt(y), 64) }
+// Even 32-bit multiply can overflow a Number, so always use BigInt
+function mul(bits) { return (x, y) => sign_extend(BigInt(x)*BigInt(y), bits) }
+function div(x, y) { return x/y }
+function min(x, y) { return x < y ? x : y }
+function max(x, y) { return x > y ? x : y }
+function and(x, y) { return zero_extend(x&y, 8) }
+function or(x, y) { return zero_extend(x|y, 8) }
+function xor(x, y) { return zero_extend(x^y, 8) }
+function andnot(x, y) { return zero_extend(x&~y, 8) }
+function avgr(x, y) { return (x + y + 1) >> 1; }
+function eq(truth) { return (x,y) => x==y ? truth : 0 }
+function ne(truth) { return (x,y) => x!=y ? truth : 0 }
+function lt(truth) { return (x, y) => x < y ? truth : 0 }
+function gt(truth) { return (x, y) => x > y ? truth : 0 }
+function le(truth) { return (x, y) => x <= y ? truth : 0 }
+function ge(truth) { return (x, y) => x >= y ? truth : 0 }
+
+function fadd(x, y) { return Math.fround(x+y) }
+function fsub(x, y) { return Math.fround(x-y) }
+function fmul(x, y) { return Math.fround(x*y) }
+function fdiv(x, y) { return Math.fround(x/y) }
+function fmin(x, y) {
+    if (x == y) return x;
+    if (x < y) return x;
+    if (y < x) return y;
+    if (isNaN(x)) return x;
+    return y;
+}
+function fmax(x, y) {
+    if (x == y) return x;
+    if (x > y) return x;
+    if (y > x) return y;
+    if (isNaN(x)) return x;
+    return y;
+}
+function dadd(x, y) { return x+y }
+function dsub(x, y) { return x-y }
+function dmul(x, y) { return x*y }
+function ddiv(x, y) { return x/y }
+var dmax = fmax;
+var dmin = fmin;
+
+function op_sat_s(bits, op) {
+    return (x, y) => {
+        return signed_saturate(op(sign_extend(x, bits),
+                                  sign_extend(y, bits)),
+                               bits);
+    }
+}
+
+function op_sat_u(bits, op) {
+    return (x, y) => {
+        return unsigned_saturate(op(zero_extend(x, bits),
+                                    zero_extend(y, bits)),
+                                 bits);
+    }
+}
+
+function add_sat_s(bits) {
+    return op_sat_s(bits, (x,y) => x+y);
+}
+function sub_sat_s(bits) {
+    return op_sat_s(bits, (x,y) => x-y);
+}
+function add_sat_u(bits) {
+    return op_sat_u(bits, (x,y) => x+y);
+}
+function sub_sat_u(bits) {
+    return op_sat_u(bits, (x,y) => x-y);
+}
+
+function max_s(bits) {
+    return (x, y) => {
+        return sign_extend(max(sign_extend(x, bits),
+                               sign_extend(y, bits)),
+                           bits);
+    }
+}
+
+function min_s(bits) {
+    return (x, y) => {
+        return sign_extend(min(sign_extend(x, bits),
+                               sign_extend(y, bits)),
+                           bits);
+    }
+}
+
+function max_u(bits) {
+    return (x, y) => {
+        return max(zero_extend(x, bits),
+                   zero_extend(y, bits));
+    }
+}
+
+function min_u(bits) {
+    return (x, y) => {
+        return min(zero_extend(x, bits),
+                   zero_extend(y, bits));
+    }
+}
+
+function pmin(x, y) { return y < x ? y : x }
+function pmax(x, y) { return x < y ? y : x }
+
+assertEq(max_s(8)(1, 2), 2);
+assertEq(max_s(8)(1, 128), 1);
+assertEq(min_s(8)(1, 2), 1);
+assertEq(min_s(8)(1, 128), -128);
+assertEq(max_u(8)(1, 2), 2);
+assertEq(max_u(8)(1, 128), 128);
+assertEq(min_u(8)(1, 2), 1);
+assertEq(min_u(8)(1, 128), 1);
+
+var binopTests =
+    [['i8x16.add', Int8Array, add(8)],
+     ['i16x8.add', Int16Array, add(16)],
+     ['i32x4.add', Int32Array, add(32)],
+     ['i64x2.add', BigInt64Array, add64],
+     ['i8x16.sub', Int8Array, sub(8)],
+     ['i16x8.sub', Int16Array, sub(16)],
+     ['i32x4.sub', Int32Array, sub(32)],
+     ['i64x2.sub', BigInt64Array, sub64],
+     ['i8x16.add_sat_s', Int8Array, add_sat_s(8)],
+     ['i8x16.add_sat_u', Uint8Array, add_sat_u(8)],
+     ['i16x8.add_sat_s', Int16Array, add_sat_s(16)],
+     ['i16x8.add_sat_u', Uint16Array, add_sat_u(16)],
+     ['i8x16.sub_sat_s', Int8Array, sub_sat_s(8)],
+     ['i8x16.sub_sat_u', Uint8Array, sub_sat_u(8)],
+     ['i16x8.sub_sat_s', Int16Array, sub_sat_s(16)],
+     ['i16x8.sub_sat_u', Uint16Array, sub_sat_u(16)],
+     ['i16x8.mul', Int16Array, mul(16)],
+     ['i32x4.mul', Int32Array, mul(32)],
+     ['i64x2.mul', BigInt64Array, mul(64)],
+     ['i8x16.avgr_u', Uint8Array, avgr],
+     ['i16x8.avgr_u', Uint16Array, avgr],
+     ['i8x16.max_s', Int8Array, max_s(8)],
+     ['i8x16.max_u', Uint8Array, max_u(8)],
+     ['i8x16.min_s', Int8Array, min_s(8)],
+     ['i8x16.min_u', Uint8Array, min_u(8)],
+     ['i16x8.max_s', Int16Array, max_s(16)],
+     ['i16x8.max_u', Uint16Array, max_u(16)],
+     ['i16x8.min_s', Int16Array, min_s(16)],
+     ['i16x8.min_u', Uint16Array, min_u(16)],
+     ['i32x4.max_s', Int32Array, max_s(32)],
+     ['i32x4.max_u', Uint32Array, max_u(32)],
+     ['i32x4.min_s', Int32Array, min_s(32)],
+     ['i32x4.min_u', Uint32Array, min_u(32)],
+     ['v128.and', Uint8Array, and],
+     ['v128.or', Uint8Array, or],
+     ['v128.xor', Uint8Array, xor],
+     ['v128.andnot', Uint8Array, andnot],
+     ['f32x4.add', Float32Array, fadd],
+     ['f32x4.sub', Float32Array, fsub],
+     ['f32x4.mul', Float32Array, fmul],
+     ['f32x4.div', Float32Array, fdiv],
+     ['f32x4.min', Float32Array, fmin],
+     ['f32x4.max', Float32Array, fmax],
+     ['f64x2.add', Float64Array, dadd],
+     ['f64x2.sub', Float64Array, dsub],
+     ['f64x2.mul', Float64Array, dmul],
+     ['f64x2.div', Float64Array, ddiv],
+     ['f64x2.min', Float64Array, dmin],
+     ['f64x2.max', Float64Array, dmax],
+     ['i8x16.eq', Int8Array, eq(-1)],
+     ['i8x16.ne', Int8Array, ne(-1)],
+     ['i8x16.lt_s', Int8Array, lt(-1)],
+     ['i8x16.gt_s', Int8Array, gt(-1)],
+     ['i8x16.le_s', Int8Array, le(-1)],
+     ['i8x16.ge_s', Int8Array, ge(-1)],
+     ['i8x16.gt_u', Uint8Array, gt(0xFF)],
+     ['i8x16.ge_u', Uint8Array, ge(0xFF)],
+     ['i8x16.lt_u', Uint8Array, lt(0xFF)],
+     ['i8x16.le_u', Uint8Array, le(0xFF)],
+     ['i16x8.eq', Int16Array, eq(-1)],
+     ['i16x8.ne', Int16Array, ne(-1)],
+     ['i16x8.lt_s', Int16Array, lt(-1)],
+     ['i16x8.gt_s', Int16Array, gt(-1)],
+     ['i16x8.le_s', Int16Array, le(-1)],
+     ['i16x8.ge_s', Int16Array, ge(-1)],
+     ['i16x8.gt_u', Uint16Array, gt(0xFFFF)],
+     ['i16x8.ge_u', Uint16Array, ge(0xFFFF)],
+     ['i16x8.lt_u', Uint16Array, lt(0xFFFF)],
+     ['i16x8.le_u', Uint16Array, le(0xFFFF)],
+     ['i32x4.eq', Int32Array, eq(-1)],
+     ['i32x4.ne', Int32Array, ne(-1)],
+     ['i32x4.lt_s', Int32Array, lt(-1)],
+     ['i32x4.gt_s', Int32Array, gt(-1)],
+     ['i32x4.le_s', Int32Array, le(-1)],
+     ['i32x4.ge_s', Int32Array, ge(-1)],
+     ['i32x4.gt_u', Uint32Array, gt(0xFFFFFFFF)],
+     ['i32x4.ge_u', Uint32Array, ge(0xFFFFFFFF)],
+     ['i32x4.lt_u', Uint32Array, lt(0xFFFFFFFF)],
+     ['i32x4.le_u', Uint32Array, le(0xFFFFFFFF)],
+     ['f32x4.eq', Float32Array, eq(-1), Int32Array],
+     ['f32x4.ne', Float32Array, ne(-1), Int32Array],
+     ['f32x4.lt', Float32Array, lt(-1), Int32Array],
+     ['f32x4.gt', Float32Array, gt(-1), Int32Array],
+     ['f32x4.le', Float32Array, le(-1), Int32Array],
+     ['f32x4.ge', Float32Array, ge(-1), Int32Array],
+     ['f64x2.eq', Float64Array, eq(-1), BigInt64Array],
+     ['f64x2.ne', Float64Array, ne(-1), BigInt64Array],
+     ['f64x2.lt', Float64Array, lt(-1), BigInt64Array],
+     ['f64x2.gt', Float64Array, gt(-1), BigInt64Array],
+     ['f64x2.le', Float64Array, le(-1), BigInt64Array],
+     ['f64x2.ge', Float64Array, ge(-1), BigInt64Array],
+     ['f32x4.pmin', Float32Array, pmin],
+     ['f32x4.pmax', Float32Array, pmax],
+     ['f64x2.pmin', Float64Array, pmin],
+     ['f64x2.pmax', Float64Array, pmax]]
+
+// Run v128 x v128 -> v128 tests.  Inputs are taken from the common input sets,
+// placed in memory, the test is run, and the result is extracted and checked.
+//
+// Runs tests with both operands as variables, either as constant, or both as
+// constant.  Also checks NaN behavior when appropriate.
+//
+// All runners that call this should use the same value for `ofParts` and should
+// pass different values for `part`, up to `ofParts` - 1.
+
+function runSimpleBinopTest(part, ofParts) {
+    let partSize = Math.ceil(binopTests.length / ofParts);
+    let start = part * partSize;
+    let end = Math.min((part + 1) * partSize, binopTests.length);
+    for ( let [op, memtype, rop, resultmemtype] of binopTests.slice(start, end) ) {
+        let inputs = cross(memtype.inputs);
+        let len = 16/memtype.BYTES_PER_ELEMENT;
+        let xs = iota(len);
+        let zero = xs.map(_ => 0);
+        let [ins, mem, resultmem] = insAndMemBinop(op, memtype, resultmemtype, inputs);
+        let bitsForF32 = memtype == Float32Array ? new Uint32Array(mem.buffer) : null;
+        let bitsForF64 = memtype == Float64Array ? new BigInt64Array(mem.buffer) : null;
+
+        function testIt(a,b,r) {
+            set(mem, len, a);
+            set(mem, len*2, b);
+            ins.exports.run();
+            assertSame(get(resultmem, 0, len), r);
+
+            // Test signalling NaN superficially by replacing QNaN inputs with SNaN
+            if (bitsForF32 != null && (a.some(isNaN) || b.some(isNaN))) {
+                a.forEach((x, i) => { if (isNaN(x)) { bitsForF32[len+i] = 0x7FA0_0000; } });
+                b.forEach((x, i) => { if (isNaN(x)) { bitsForF32[(len*2)+i] = 0x7FA0_0000; } });
+                ins.exports.run();
+                assertSame(get(resultmem, 0, len), r);
+            }
+            if (bitsForF64 != null && (a.some(isNaN) || b.some(isNaN))) {
+                a.forEach((x, i) => { if (isNaN(x)) { bitsForF64[len+i] = 0x7FF4_0000_0000_0000n; } });
+                b.forEach((x, i) => { if (isNaN(x)) { bitsForF64[(len*2)+i] = 0x7FF4_0000_0000_0000n; } });
+                ins.exports.run();
+                assertSame(get(resultmem, 0, len), r);
+            }
+        }
+
+        function testConstIt(i,r) {
+            set(resultmem, 0, zero);
+            ins.exports["run_constlhs" + i]();
+            assertSame(get(resultmem, 0, len), r);
+
+            set(resultmem, 0, zero);
+            ins.exports["run_constrhs" + i]();
+            assertSame(get(resultmem, 0, len), r);
+
+            set(resultmem, 0, zero);
+            ins.exports["run_constboth" + i]();
+            assertSame(get(resultmem, 0, len), r);
+        }
+
+        let i = 0;
+        for (let [a,b] of inputs) {
+            let r = xs.map((i) => rop(a[i], b[i]));
+            testIt(a,b,r);
+            testConstIt(i,r);
+            i++;
+        }
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-extra.js b/js/src/jit-test/tests/wasm/simd/ad-hack-extra.js
new file mode 100644
index 0000000000..ee770d16a9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-extra.js
@@ -0,0 +1,697 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Do not include this in the preamble, it must be loaded after lib/wasm.js
+load(scriptdir + "ad-hack-preamble.js")
+
+// Widening multiplication.
+// This is to be moved into ad-hack.js
+//
+//   (iMxN.extmul_{high,low}_iKxL_{s,u} A B)
+//
+// is equivalent to
+//
+//   (iMxN.mul (iMxN.extend_{high,low}_iKxL_{s,u} A)
+//             (iMxN.extend_{high,low}_iKxL_{s,u} B))
+//
+// It doesn't really matter what the inputs are, we can test this almost
+// blindly.
+//
+// Unfortunately, we do not yet have i64x2.extend_* so we introduce a helper
+// function to compute that.
+
+function makeExtMulTest(wide, narrow, part, signed) {
+    let widener = (wide == 'i64x2') ?
+        `call $${wide}_extend_${part}_${narrow}_${signed}` :
+        `${wide}.extend_${part}_${narrow}_${signed}`;
+    return `
+    (func (export "${wide}_extmul_${part}_${narrow}_${signed}")
+      (v128.store (i32.const 0)
+         (${wide}.extmul_${part}_${narrow}_${signed} (v128.load (i32.const 16))
+                                                     (v128.load (i32.const 32))))
+      (v128.store (i32.const 48)
+         (${wide}.mul (${widener} (v128.load (i32.const 16)))
+                      (${widener} (v128.load (i32.const 32))))))
+`;
+}
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $i64x2_extend_low_i32x4_s (param v128) (result v128)
+      (i64x2.shr_s (i8x16.shuffle 16 16 16 16 0 1 2 3 16 16 16 16 4 5 6 7
+                                  (local.get 0)
+                                  (v128.const i32x4 0 0 0 0))
+                   (i32.const 32)))
+    (func $i64x2_extend_high_i32x4_s (param v128) (result v128)
+      (i64x2.shr_s (i8x16.shuffle 16 16 16 16 8 9 10 11 16 16 16 16 12 13 14 15
+                                  (local.get 0)
+                                  (v128.const i32x4 0 0 0 0))
+                   (i32.const 32)))
+    (func $i64x2_extend_low_i32x4_u (param v128) (result v128)
+      (i8x16.shuffle 0 1 2 3 16 16 16 16 4 5 6 7 16 16 16 16
+                     (local.get 0)
+                     (v128.const i32x4 0 0 0 0)))
+    (func $i64x2_extend_high_i32x4_u (param v128) (result v128)
+      (i8x16.shuffle 8 9 10 11 16 16 16 16 12 13 14 15 16 16 16 16
+                     (local.get 0)
+                     (v128.const i32x4 0 0 0 0)))
+    ${makeExtMulTest('i64x2','i32x4','low','s')}
+    ${makeExtMulTest('i64x2','i32x4','high','s')}
+    ${makeExtMulTest('i64x2','i32x4','low','u')}
+    ${makeExtMulTest('i64x2','i32x4','high','u')}
+    ${makeExtMulTest('i32x4','i16x8','low','s')}
+    ${makeExtMulTest('i32x4','i16x8','high','s')}
+    ${makeExtMulTest('i32x4','i16x8','low','u')}
+    ${makeExtMulTest('i32x4','i16x8','high','u')}
+    ${makeExtMulTest('i16x8','i8x16','low','s')}
+    ${makeExtMulTest('i16x8','i8x16','high','s')}
+    ${makeExtMulTest('i16x8','i8x16','low','u')}
+    ${makeExtMulTest('i16x8','i8x16','high','u')})`);
+
+for ( let [ WideArray, NarrowArray ] of
+      [ [ Int16Array, Int8Array ],
+        [ Int32Array, Int16Array ],
+        [ BigInt64Array, Int32Array ] ] ) {
+    let narrowMem = new NarrowArray(ins.exports.mem.buffer);
+    let narrowSrc0 = 16/NarrowArray.BYTES_PER_ELEMENT;
+    let narrowSrc1 = 32/NarrowArray.BYTES_PER_ELEMENT;
+    let wideMem = new WideArray(ins.exports.mem.buffer);
+    let wideElems = 16/WideArray.BYTES_PER_ELEMENT;
+    let wideRes0 = 0;
+    let wideRes1 = 48/WideArray.BYTES_PER_ELEMENT;
+    let zero = iota(wideElems).map(_ => 0);
+    for ( let part of [ 'low', 'high' ] ) {
+        for ( let signed of [ 's', 'u' ] ) {
+            for ( let [a, b] of cross(NarrowArray.inputs) ) {
+                set(wideMem, wideRes0, zero);
+                set(wideMem, wideRes1, zero);
+                set(narrowMem, narrowSrc0, a);
+                set(narrowMem, narrowSrc1, b);
+                let test = `${WideArray.layoutName}_extmul_${part}_${NarrowArray.layoutName}_${signed}`;
+                ins.exports[test]();
+                assertSame(get(wideMem, wideRes0, wideElems),
+                           get(wideMem, wideRes1, wideElems));
+            }
+        }
+    }
+}
+
+// Bitmask.  Ion constant folds, so test that too.
+// This is to be merged into the existing bitmask tests in ad-hack.js.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "bitmask_i64x2") (result i32)
+      (i64x2.bitmask (v128.load (i32.const 16))))
+    (func (export "const_bitmask_i64x2") (result i32)
+      (i64x2.bitmask (v128.const i64x2 0xff337f8012345678 0x0001984212345678))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var mem64 = new BigUint64Array(ins.exports.mem.buffer);
+
+set(mem8, 16, iota(16).map((_) => 0));
+assertEq(ins.exports.bitmask_i64x2(), 0);
+
+set(mem64, 2, [0x8000000000000000n, 0x8000000000000000n]);
+assertEq(ins.exports.bitmask_i64x2(), 3);
+
+set(mem64, 2, [0x7FFFFFFFFFFFFFFFn, 0x7FFFFFFFFFFFFFFFn]);
+assertEq(ins.exports.bitmask_i64x2(), 0);
+
+set(mem64, 2, [0n, 0x8000000000000000n]);
+assertEq(ins.exports.bitmask_i64x2(), 2);
+
+set(mem64, 2, [0x8000000000000000n, 0n]);
+assertEq(ins.exports.bitmask_i64x2(), 1);
+
+assertEq(ins.exports.const_bitmask_i64x2(), 1);
+
+// Widen low/high.
+// This is to be merged into the existing widening tests in ad-hack.js.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "extend_low_i32x4_s")
+      (v128.store (i32.const 0) (i64x2.extend_low_i32x4_s (v128.load (i32.const 16)))))
+    (func (export "extend_high_i32x4_s")
+      (v128.store (i32.const 0) (i64x2.extend_high_i32x4_s (v128.load (i32.const 16)))))
+    (func (export "extend_low_i32x4_u")
+      (v128.store (i32.const 0) (i64x2.extend_low_i32x4_u (v128.load (i32.const 16)))))
+    (func (export "extend_high_i32x4_u")
+      (v128.store (i32.const 0) (i64x2.extend_high_i32x4_u (v128.load (i32.const 16))))))`);
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+var mem64u = new BigUint64Array(ins.exports.mem.buffer);
+
+var as = [205, 1, 192, 3].map((x) => x << 24);
+set(mem32, 4, as);
+
+ins.exports.extend_low_i32x4_s();
+assertSame(get(mem64, 0, 2), iota(2).map((n) => BigInt(as[n])))
+
+ins.exports.extend_high_i32x4_s();
+assertSame(get(mem64, 0, 2), iota(2).map((n) => BigInt(as[n+2])));
+
+ins.exports.extend_low_i32x4_u();
+assertSame(get(mem64u, 0, 2), iota(2).map((n) => BigInt(as[n] >>> 0)));
+
+ins.exports.extend_high_i32x4_u();
+assertSame(get(mem64u, 0, 2), iota(2).map((n) => BigInt(as[n+2] >>> 0)));
+
+// Saturating rounding q-format multiplication.
+// This is to be moved into ad-hack.js
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "q15mulr_sat_s")
+      (v128.store (i32.const 0) (i16x8.q15mulr_sat_s (v128.load (i32.const 16)) (v128.load (i32.const 32))))))`);
+
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+for ( let [as, bs] of cross(Int16Array.inputs) ) {
+    set(mem16, 8, as);
+    set(mem16, 16, bs);
+    ins.exports.q15mulr_sat_s();
+    assertSame(get(mem16, 0, 8),
+               iota(8).map((i) => signed_saturate((as[i] * bs[i] + 0x4000) >> 15, 16)));
+}
+
+
+// i64.all_true
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "i64_all_true") (result i32)
+      (i64x2.all_true (v128.load (i32.const 16)) ) ) )`);
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+
+set(mem32, 4, [0, 0, 0, 0]);
+assertEq(0, ins.exports.i64_all_true());
+set(mem32, 4, [1, 0, 0, 0]);
+assertEq(0, ins.exports.i64_all_true());
+set(mem32, 4, [1, 0, 0, 1]);
+assertEq(1, ins.exports.i64_all_true());
+set(mem32, 4, [0, 0, 10, 0]);
+assertEq(0, ins.exports.i64_all_true());
+set(mem32, 4, [0, -250, 1, 0]);
+assertEq(1, ins.exports.i64_all_true());
+set(mem32, 4, [-1, -1, -1, -1]);
+assertEq(1, ins.exports.i64_all_true());
+
+if (this.wasmSimdAnalysis && wasmCompileMode() == "ion") {
+  const positive =
+      wasmCompile(
+          `(module
+              (memory (export "mem") 1 1)
+              (func $f (param v128) (result i32)
+                  (if (result i32) (i64x2.all_true (local.get 0))
+                      (i32.const 42)
+                      (i32.const 37)))
+              (func (export "run") (result i32)
+                (call $f (v128.load (i32.const 16)))))`);
+  assertEq(wasmSimdAnalysis(), "simd128-to-scalar-and-branch -> folded");
+
+  const negative =
+      wasmCompile(
+          `(module
+              (memory (export "mem") 1 1)
+              (func $f (param v128) (result i32)
+                  (if (result i32) (i32.eqz (i64x2.all_true (local.get 0)))
+                      (i32.const 42)
+                      (i32.const 37)))
+              (func (export "run") (result i32)
+                (call $f (v128.load (i32.const 16)))))`);
+  assertEq(wasmSimdAnalysis(), "simd128-to-scalar-and-branch -> folded");
+
+  for ( let inp of [[1n, 2n], [4n, 0n], [0n, 0n]]) {
+      const all_true = inp.every(v => v != 0n)
+      let mem = new BigInt64Array(positive.exports.mem.buffer);
+      set(mem, 2, inp);
+      assertEq(positive.exports.run(), all_true ? 42 : 37);
+
+      mem = new BigInt64Array(negative.exports.mem.buffer);
+      set(mem, 2, inp);
+      assertEq(negative.exports.run(), all_true ? 37 : 42);
+  }
+
+  wasmCompile(`(module (func (result i32) (i64x2.all_true (v128.const i64x2 0 0))))`);
+  assertEq(wasmSimdAnalysis(), "simd128-to-scalar -> constant folded");
+}
+
+
+// i64x2.eq and i64x2.ne
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "i64_eq")
+      (v128.store (i32.const 0)
+        (i64x2.eq (v128.load (i32.const 16)) (v128.load (i32.const 32))) ))
+    (func (export "i64_ne")
+      (v128.store (i32.const 0)
+         (i64x2.ne (v128.load (i32.const 16)) (v128.load (i32.const 32))) )) )`);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+
+set(mem64, 2, [0n, 1n, 0n, 1n]);
+ins.exports.i64_eq();
+assertSame(get(mem64, 0, 2), [-1n, -1n]);
+ins.exports.i64_ne();
+assertSame(get(mem64, 0, 2), [0n, 0n]);
+set(mem64, 2, [0x0n, -1n, 0x100000000n, -1n]);
+ins.exports.i64_eq();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+set(mem64, 2, [-1n, 0x0n, -1n, 0x100000000n]);
+ins.exports.i64_ne();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+
+
+// i64x2.lt, i64x2.gt, i64x2.le, and i64.ge
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "i64_lt_s")
+      (v128.store (i32.const 0)
+        (i64x2.lt_s (v128.load (i32.const 16)) (v128.load (i32.const 32))) ))
+    (func (export "i64_gt_s")
+      (v128.store (i32.const 0)
+        (i64x2.gt_s (v128.load (i32.const 16)) (v128.load (i32.const 32))) ))
+    (func (export "i64_le_s")
+      (v128.store (i32.const 0)
+        (i64x2.le_s (v128.load (i32.const 16)) (v128.load (i32.const 32))) ))
+    (func (export "i64_ge_s")
+      (v128.store (i32.const 0)
+        (i64x2.ge_s (v128.load (i32.const 16)) (v128.load (i32.const 32))) )) )`);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+
+set(mem64, 2, [0n, 1n, 1n, 0n]);
+ins.exports.i64_lt_s();
+assertSame(get(mem64, 0, 2), [-1n, 0n]);
+ins.exports.i64_gt_s();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+ins.exports.i64_le_s();
+assertSame(get(mem64, 0, 2), [-1n, 0n]);
+ins.exports.i64_ge_s();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+
+set(mem64, 2, [0n, -1n, -1n, 0n]);
+ins.exports.i64_lt_s();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+ins.exports.i64_gt_s();
+assertSame(get(mem64, 0, 2), [-1n, 0n]);
+ins.exports.i64_le_s();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+ins.exports.i64_ge_s();
+assertSame(get(mem64, 0, 2), [-1n, 0n]);
+
+set(mem64, 2, [-2n, 2n, -1n, 1n]);
+ins.exports.i64_lt_s();
+assertSame(get(mem64, 0, 2), [-1n, 0n]);
+ins.exports.i64_gt_s();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+ins.exports.i64_le_s();
+assertSame(get(mem64, 0, 2), [-1n, 0n]);
+ins.exports.i64_ge_s();
+assertSame(get(mem64, 0, 2), [0n, -1n]);
+
+set(mem64, 2, [-2n, 1n, -2n, 1n]);
+ins.exports.i64_lt_s();
+assertSame(get(mem64, 0, 2), [0n, 0n]);
+ins.exports.i64_gt_s();
+assertSame(get(mem64, 0, 2), [0n, 0n]);
+ins.exports.i64_le_s();
+assertSame(get(mem64, 0, 2), [-1n, -1n]);
+ins.exports.i64_ge_s();
+assertSame(get(mem64, 0, 2), [-1n, -1n]);
+
+
+function wasmCompile(text) {
+  return new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(text)))
+}
+
+
+// i64x2.abs
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "i64_abs")
+      (v128.store (i32.const 0)
+        (i64x2.abs (v128.load (i32.const 16))) )) )`);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+
+set(mem64, 2, [-3n, 42n]);
+ins.exports.i64_abs();
+assertSame(get(mem64, 0, 2), [3n, 42n]);
+set(mem64, 2, [0n, -0x8000000000000000n]);
+ins.exports.i64_abs();
+assertSame(get(mem64, 0, 2), [0n, -0x8000000000000000n]);
+
+
+// Load lane
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    ${iota(16).map(i => `(func (export "load8_lane_${i}") (param i32)
+      (v128.store (i32.const 0)
+        (v128.load8_lane offset=0 ${i} (local.get 0) (v128.load (i32.const 16)))))
+    `).join('')}
+    ${iota(8).map(i => `(func (export "load16_lane_${i}") (param i32)
+    (v128.store (i32.const 0)
+      (v128.load16_lane offset=0 ${i} (local.get 0) (v128.load (i32.const 16)))))
+    `).join('')}
+    ${iota(4).map(i => `(func (export "load32_lane_${i}") (param i32)
+    (v128.store (i32.const 0)
+      (v128.load32_lane offset=0 ${i} (local.get 0) (v128.load (i32.const 16)))))
+    `).join('')}
+    ${iota(2).map(i => `(func (export "load64_lane_${i}") (param i32)
+    (v128.store (i32.const 0)
+      (v128.load64_lane offset=0 ${i} (local.get 0) (v128.load (i32.const 16)))))
+    `).join('')}
+    (func (export "load_lane_const_and_align")
+      (v128.store (i32.const 0)
+        (v128.load64_lane offset=32 1 (i32.const 1)
+          (v128.load32_lane offset=32 1 (i32.const 3)
+            (v128.load16_lane offset=32 0 (i32.const 5)
+              (v128.load (i32.const 16)))))
+      ))
+  )`);
+
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+
+var as = [0x12345678, 0x23456789, 0x3456789A, 0x456789AB];
+set(mem32, 4, as); set(mem8, 32, [0xC2]);
+
+ins.exports["load8_lane_0"](32);
+assertSame(get(mem32, 0, 4), [0x123456C2, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load8_lane_1"](32);
+assertSame(get(mem32, 0, 4), [0x1234C278, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load8_lane_2"](32);
+assertSame(get(mem32, 0, 4), [0x12C25678, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load8_lane_3"](32);
+assertSame(get(mem32, 0, 4), [0xC2345678|0, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load8_lane_4"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x234567C2, 0x3456789A, 0x456789AB]);
+ins.exports["load8_lane_6"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23C26789, 0x3456789A, 0x456789AB]);
+ins.exports["load8_lane_9"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23456789, 0x3456C29A, 0x456789AB]);
+ins.exports["load8_lane_14"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23456789, 0x3456789A, 0x45C289AB]);
+
+set(mem8, 32, [0xC2, 0xD1]);
+
+ins.exports["load16_lane_0"](32);
+assertSame(get(mem32, 0, 4), [0x1234D1C2, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load16_lane_1"](32);
+assertSame(get(mem32, 0, 4), [0xD1C25678|0, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load16_lane_2"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x2345D1C2, 0x3456789A, 0x456789AB]);
+ins.exports["load16_lane_5"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23456789, 0xD1C2789A|0, 0x456789AB]);
+ins.exports["load16_lane_7"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23456789, 0x3456789A, 0xD1C289AB|0]);
+
+set(mem32, 8, [0x16B5C3D0]);
+
+ins.exports["load32_lane_0"](32);
+assertSame(get(mem32, 0, 4), [0x16B5C3D0, 0x23456789, 0x3456789A, 0x456789AB]);
+ins.exports["load32_lane_1"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x16B5C3D0, 0x3456789A, 0x456789AB]);
+ins.exports["load32_lane_2"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23456789, 0x16B5C3D0, 0x456789AB]);
+ins.exports["load32_lane_3"](32);
+assertSame(get(mem32, 0, 4), [0x12345678, 0x23456789, 0x3456789A, 0x16B5C3D0]);
+
+set(mem64, 4, [0x3300AA4416B5C3D0n]);
+
+ins.exports["load64_lane_0"](32);
+assertSame(get(mem64, 0, 2), [0x3300AA4416B5C3D0n, 0x456789AB3456789An]);
+ins.exports["load64_lane_1"](32);
+assertSame(get(mem64, 0, 2), [0x2345678912345678n, 0x3300AA4416B5C3D0n]);
+
+// .. (mis)align load lane
+
+var as = [0x12345678, 0x23456789, 0x3456789A, 0x456789AB];
+set(mem32, 4, as); set(mem64, 4, [0x3300AA4416B5C3D0n, 0x300AA4416B5C3D03n]);
+
+ins.exports["load16_lane_5"](33);
+assertSame(get(mem32, 0, 4), [0x12345678,0x23456789,0xb5c3789a|0,0x456789ab]);
+ins.exports["load32_lane_1"](34);
+assertSame(get(mem32, 0, 4), [0x12345678, 0xaa4416b5|0,0x3456789a,0x456789ab]);
+ins.exports["load64_lane_0"](35);
+assertSame(get(mem64, 0, 2), [0x5c3d033300aa4416n, 0x456789ab3456789an]);
+
+ins.exports["load_lane_const_and_align"]();
+assertSame(get(mem32, 0, 4), [0x123400aa,0x00AA4416,0x4416b5c3,0x033300aa]);
+
+// Store lane
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    ${iota(16).map(i => `(func (export "store8_lane_${i}") (param i32) (param i32)
+      (v128.store8_lane ${i} (local.get 1) (v128.load (local.get 0))))
+    `).join('')}
+    ${iota(8).map(i => `(func (export "store16_lane_${i}") (param i32) (param i32)
+      (v128.store16_lane ${i} (local.get 1) (v128.load (local.get 0))))
+    `).join('')}
+    ${iota(4).map(i => `(func (export "store32_lane_${i}") (param i32) (param i32)
+      (v128.store32_lane ${i} (local.get 1) (v128.load (local.get 0))))
+    `).join('')}
+    ${iota(2).map(i => `(func (export "store64_lane_${i}") (param i32) (param i32)
+      (v128.store64_lane ${i} (local.get 1) (v128.load (local.get 0))))
+    `).join('')}
+    (func (export "store_lane_const_and_align")
+      (v128.store16_lane 1 (i32.const 33) (v128.load (i32.const 16)))
+      (v128.store32_lane 2 (i32.const 37) (v128.load (i32.const 16)))
+      (v128.store64_lane 0 (i32.const 47) (v128.load (i32.const 16)))
+    ))`);
+
+
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+
+var as = [0x12345678, 0x23456789, 0x3456789A, 0x456789AB];
+set(mem32, 4, as); set(mem32, 0, [0x7799AA00, 42, 3, 0]);
+
+ins.exports["store8_lane_0"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA78]);
+ins.exports["store8_lane_1"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA56]);
+ins.exports["store8_lane_2"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA34]);
+ins.exports["store8_lane_3"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA12]);
+ins.exports["store8_lane_5"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA67]);
+ins.exports["store8_lane_7"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA23]);
+ins.exports["store8_lane_8"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA9A]);
+ins.exports["store8_lane_15"](16, 0); assertSame(get(mem32, 0, 1), [0x7799AA45]);
+
+ins.exports["store16_lane_0"](16, 0); assertSame(get(mem32, 0, 1), [0x77995678]);
+ins.exports["store16_lane_1"](16, 0); assertSame(get(mem32, 0, 1), [0x77991234]);
+ins.exports["store16_lane_2"](16, 0); assertSame(get(mem32, 0, 1), [0x77996789]);
+ins.exports["store16_lane_5"](16, 0); assertSame(get(mem32, 0, 1), [0x77993456]);
+ins.exports["store16_lane_7"](16, 0); assertSame(get(mem32, 0, 1), [0x77994567]);
+
+ins.exports["store32_lane_0"](16, 0); assertSame(get(mem32, 0, 2), [0x12345678, 42]);
+ins.exports["store32_lane_1"](16, 0); assertSame(get(mem32, 0, 2), [0x23456789, 42]);
+ins.exports["store32_lane_2"](16, 0); assertSame(get(mem32, 0, 2), [0x3456789A, 42]);
+ins.exports["store32_lane_3"](16, 0); assertSame(get(mem32, 0, 2), [0x456789AB, 42]);
+
+ins.exports["store64_lane_0"](16, 0); assertSame(get(mem64, 0, 2), [0x2345678912345678n, 3]);
+ins.exports["store64_lane_1"](16, 0); assertSame(get(mem64, 0, 2), [0x456789AB3456789An, 3]);
+
+// .. (mis)align store lane
+
+var as = [0x12345678, 0x23456789, 0x3456789A, 0x456789AB];
+set(mem32, 4, as); set(mem32, 0, [0x7799AA01, 42, 3, 0]);
+ins.exports["store16_lane_1"](16, 1); assertSame(get(mem32, 0, 2), [0x77123401, 42]);
+set(mem32, 0, [0x7799AA01, 42, 3, 0]);
+ins.exports["store32_lane_1"](16, 2); assertSame(get(mem32, 0, 2), [0x6789AA01, 0x2345]);
+set(mem32, 0, [0x7799AA01, 42, 5, 3]);
+ins.exports["store64_lane_0"](16, 1);
+assertSame(get(mem64, 0, 2), [0x4567891234567801n, 0x0300000023]);
+
+set(mem32, 4, [
+  0x12345678, 0x23456789, 0x3456789A, 0x456789AB,
+  0x55AA55AA, 0xCC44CC44, 0x55AA55AA, 0xCC44CC44,
+  0x55AA55AA, 0xCC44CC44, 0x55AA55AA, 0xCC44CC44,
+]);
+ins.exports["store_lane_const_and_align"]();
+assertSame(get(mem32, 8, 8), [
+  0x551234aa, 0x56789a44, 0x55aa5534, 0x7844cc44,
+  0x89123456|0, 0xcc234567|0, 0x55aa55aa, 0xcc44cc44|0,
+]);
+
+
+// i8x16.popcnt
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "i8x16_popcnt")
+      (v128.store (i32.const 0) (i8x16.popcnt (v128.load (i32.const 16)) )))
+  )`);
+
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+
+set(mem8, 16, [0, 1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80, 3, -1, 0xF0, 0x11, 0xFE, 0x0F, 0xE]);
+ins.exports.i8x16_popcnt();
+assertSame(get(mem8, 0, 16), [0,1,1,1,1,1,1,1,1,2,8,4,2,7,4,3]);
+
+
+/// Double-precision conversion instructions.
+/// f64x2.convert_low_i32x4_{u,s} / i32x4.trunc_sat_f64x2_{u,s}_zero
+/// f32x4.demote_f64x2_zero / f64x2.promote_low_f32x4
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "f64x2_convert_low_i32x4_s")
+      (v128.store (i32.const 0) (f64x2.convert_low_i32x4_s (v128.load (i32.const 16)) )))
+    (func (export "f64x2_convert_low_i32x4_u")
+      (v128.store (i32.const 0) (f64x2.convert_low_i32x4_u (v128.load (i32.const 16)) )))
+
+    (func (export "i32x4_trunc_sat_f64x2_s_zero")
+      (v128.store (i32.const 0) (i32x4.trunc_sat_f64x2_s_zero (v128.load (i32.const 16)) )))
+    (func (export "i32x4_trunc_sat_f64x2_u_zero")
+      (v128.store (i32.const 0) (i32x4.trunc_sat_f64x2_u_zero (v128.load (i32.const 16)) )))
+
+    (func (export "f32x4_demote_f64x2")
+      (v128.store (i32.const 0) (f32x4.demote_f64x2_zero (v128.load (i32.const 16)) )))
+    (func (export "f64x2_protomote_f32x4")
+      (v128.store (i32.const 0) (f64x2.promote_low_f32x4 (v128.load (i32.const 16)) )))
+  )`);
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var memU32 = new Uint32Array(ins.exports.mem.buffer);
+var memF32 = new Float32Array(ins.exports.mem.buffer);
+var memF64 = new Float64Array(ins.exports.mem.buffer);
+
+// f64x2.convert_low_i32x4_u / f64x2.convert_low_i32x4_s
+
+set(mem32, 4, [1, -2, 0, -2]);
+ins.exports.f64x2_convert_low_i32x4_s();
+assertSame(get(memF64, 0, 2), [1, -2]);
+set(mem32, 4, [-1, 0, 5, -212312312]);
+ins.exports.f64x2_convert_low_i32x4_s();
+assertSame(get(memF64, 0, 2), [-1, 0]);
+
+set(memU32, 4, [1, 4045646797, 4, 0]);
+ins.exports.f64x2_convert_low_i32x4_u();
+assertSame(get(memF64, 0, 2), [1, 4045646797]);
+set(memU32, 4, [0, 2, 4, 3]);
+ins.exports.f64x2_convert_low_i32x4_u();
+assertSame(get(memF64, 0, 2), [0, 2]);
+
+// i32x4.trunc_sat_f64x2_u_zero / i32x4.trunc_sat_f64x2_s_zero
+
+set(memF64, 2, [0,0])
+ins.exports.i32x4_trunc_sat_f64x2_s_zero();
+assertSame(get(mem32, 0, 4), [0,0,0,0]);
+ins.exports.i32x4_trunc_sat_f64x2_u_zero();
+assertSame(get(memU32, 0, 4), [0,0,0,0]);
+
+set(memF64, 2, [-1.23,65535.12])
+ins.exports.i32x4_trunc_sat_f64x2_s_zero();
+assertSame(get(mem32, 0, 4), [-1,65535,0,0]);
+set(memF64, 2, [1.99,65535.12])
+ins.exports.i32x4_trunc_sat_f64x2_u_zero();
+assertSame(get(memU32, 0, 4), [1,65535,0,0]);
+
+set(memF64, 2, [10e+100,-10e+100])
+ins.exports.i32x4_trunc_sat_f64x2_s_zero();
+assertSame(get(mem32, 0, 4), [0x7fffffff,-0x80000000,0,0]);
+ins.exports.i32x4_trunc_sat_f64x2_u_zero();
+assertSame(get(memU32, 0, 4), [0xffffffff,0,0,0]);
+
+// f32x4.demote_f64x2_zero
+
+set(memF64, 2, [1, 2])
+ins.exports.f32x4_demote_f64x2();
+assertSame(get(memF32, 0, 4), [1,2,0,0]);
+
+set(memF64, 2, [-4e38, 4e38])
+ins.exports.f32x4_demote_f64x2();
+assertSame(get(memF32, 0, 4), [-Infinity,Infinity,0,0]);
+
+set(memF64, 2, [-1e-46, 1e-46])
+ins.exports.f32x4_demote_f64x2();
+assertSame(get(memF32, 0, 4), [1/-Infinity,0,0,0]);
+
+set(memF64, 2, [0, NaN])
+ins.exports.f32x4_demote_f64x2();
+assertSame(get(memF32, 0, 4), [0, NaN,0,0]);
+
+set(memF64, 2, [Infinity, -Infinity])
+ins.exports.f32x4_demote_f64x2();
+assertSame(get(memF32, 0, 4), [Infinity, -Infinity,0,0]);
+
+// f64x2.promote_low_f32x4
+
+set(memF32, 4, [4, 3, 1, 2])
+ins.exports.f64x2_protomote_f32x4();
+assertSame(get(memF64, 0, 2), [4, 3]);
+
+set(memF32, 4, [NaN, 0, 0, 0])
+ins.exports.f64x2_protomote_f32x4();
+assertSame(get(memF64, 0, 2), [NaN, 0]);
+
+set(memF32, 4, [Infinity, -Infinity, 0, 0])
+ins.exports.f64x2_protomote_f32x4();
+assertSame(get(memF64, 0, 2), [Infinity, -Infinity]);
+
+
+// i16x8.extadd_pairwise_i8x16_{s,u} / i32x4.extadd_pairwise_i16x8_{s,u}
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "i16x8_extadd_pairwise_i8x16_s")
+      (v128.store (i32.const 0) (i16x8.extadd_pairwise_i8x16_s (v128.load (i32.const 16)) )))
+    (func (export "i16x8_extadd_pairwise_i8x16_u")
+      (v128.store (i32.const 0) (i16x8.extadd_pairwise_i8x16_u (v128.load (i32.const 16)) )))
+
+    (func (export "i32x4_extadd_pairwise_i16x8_s")
+      (v128.store (i32.const 0) (i32x4.extadd_pairwise_i16x8_s (v128.load (i32.const 16)) )))
+    (func (export "i32x4_extadd_pairwise_i16x8_u")
+      (v128.store (i32.const 0) (i32x4.extadd_pairwise_i16x8_u (v128.load (i32.const 16)) )))
+  )`);
+
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+var memU8 = new Uint8Array(ins.exports.mem.buffer);
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+var memU16 = new Uint16Array(ins.exports.mem.buffer);
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var memU32 = new Uint32Array(ins.exports.mem.buffer);
+
+set(mem8, 16, [0, 0, 1, 1, 2, -2, 0, 42, 1, -101, 101, -1, 127, 125, -1, -2]);
+ins.exports.i16x8_extadd_pairwise_i8x16_s();
+assertSame(get(mem16, 0, 8), [0, 2, 0, 42, -100, 100, 252, -3]);
+
+set(memU8, 16, [0, 0, 1, 1, 2, 255, 0, 42, 0, 255, 254, 0, 127, 125, 255, 255]);
+ins.exports.i16x8_extadd_pairwise_i8x16_u();
+assertSame(get(memU16, 0, 8), [0, 2, 257, 42, 255, 254, 252, 510]);
+
+set(mem16, 8, [0, 0, 1, 1, 2, -2, -1, -2]);
+ins.exports.i32x4_extadd_pairwise_i16x8_s();
+assertSame(get(mem32, 0, 4), [0, 2, 0, -3]);
+set(mem16, 8, [0, 42, 1, -32760, 32766, -1, 32761, 32762]);
+ins.exports.i32x4_extadd_pairwise_i16x8_s();
+assertSame(get(mem32, 0, 4), [42, -32759, 32765, 65523]);
+
+set(memU16, 8, [0, 0, 1, 1, 2, 65535, 65535, 65535]);
+ins.exports.i32x4_extadd_pairwise_i16x8_u();
+assertSame(get(memU32, 0, 4), [0, 2, 65537, 131070]);
+set(memU16, 8, [0, 42, 0, 65535, 65534, 0, 32768, 32765]);
+ins.exports.i32x4_extadd_pairwise_i16x8_u();
+assertSame(get(memU32, 0, 4), [42, 65535, 65534, 65533]);
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-preamble.js b/js/src/jit-test/tests/wasm/simd/ad-hack-preamble.js
new file mode 100644
index 0000000000..407b59476f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-preamble.js
@@ -0,0 +1,211 @@
+// |jit-test| skip-if: true
+
+// Common code for the ad-hack test cases.
+
+function get(arr, loc, len) {
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        res.push(arr[loc+i]);
+    }
+    return res;
+}
+
+function getUnaligned(arr, width, loc, len) {
+    assertEq(arr.constructor, Uint8Array);
+    assertEq(width <= 4, true);
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        let x = 0;
+        for ( let j=width-1; j >=0; j-- )
+            x = (x << 8) | arr[loc+i*width+j];
+        res.push(x);
+    }
+    return res;
+}
+
+function set(arr, loc, vals) {
+    for ( let i=0; i < vals.length; i++ ) {
+        if (arr instanceof BigInt64Array) {
+            arr[loc+i] = BigInt(vals[i]);
+        } else {
+            arr[loc+i] = vals[i];
+        }
+    }
+}
+
+function setUnaligned(arr, width, loc, vals) {
+    assertEq(arr.constructor, Uint8Array);
+    assertEq(width <= 4, true);
+    for ( let i=0; i < vals.length; i++ ) {
+        let x = vals[i];
+        for ( let j=0 ; j < width ; j++ ) {
+            arr[loc+i*width + j] = x & 255;
+            x >>= 8;
+        }
+    }
+}
+
+function equal(a, b) {
+    return a === b || isNaN(a) && isNaN(b);
+}
+
+function upd(xs, at, val) {
+    let ys = Array.from(xs);
+    ys[at] = val;
+    return ys;
+}
+
+// The following operations are not always generalized fully, they are just
+// functional enough for the existing test cases to pass.
+
+function sign_extend(n, bits) {
+    if (bits < 32) {
+        n = Number(n);
+        return (n << (32 - bits)) >> (32 - bits);
+    }
+    if (typeof n == "bigint") {
+        if (bits == 32)
+            return Number(n & 0xFFFF_FFFFn) | 0;
+        assertEq(bits, 64);
+        n = (n & 0xFFFF_FFFF_FFFF_FFFFn)
+        if (n > 0x7FFF_FFFF_FFFF_FFFFn)
+            return n - 0x1_0000_0000_0000_0000n;
+        return n;
+    }
+    assertEq(bits, 32);
+    return n|0;
+}
+
+function zero_extend(n, bits) {
+    if (bits < 32) {
+        return n & ((1 << bits) - 1);
+    }
+    if (n < 0)
+        n = 0x100000000 + n;
+    return n;
+}
+
+function signed_saturate(z, bits) {
+    let min = -(1 << (bits-1));
+    if (z <= min) {
+        return min;
+    }
+    let max = (1 << (bits-1)) - 1;
+    if (z > max) {
+        return max;
+    }
+    return z;
+}
+
+function unsigned_saturate(z, bits) {
+    if (z <= 0) {
+        return 0;
+    }
+    let max = (1 << bits) - 1;
+    if (z > max) {
+        return max;
+    }
+    return z;
+}
+
+function shl(count, width) {
+    if (width == 64) {
+        count = BigInt(count);
+        return (v) => {
+            v = BigInt(v);
+            if (v < 0)
+                v = (1n << 64n) + v;
+            let r = (v << count) & ((1n << 64n) - 1n);
+            if (r & (1n << 63n))
+                r = -((1n << 64n) - r);
+            return r;
+        }
+    } else {
+        return (v) => {
+            let mask = (width == 32) ? -1 : ((1 << width) - 1);
+            return (v << count) & mask;
+        }
+    }
+}
+
+function popcount(n) {
+  n = n - ((n >> 1) & 0x55555555)
+  n = (n & 0x33333333) + ((n >> 2) & 0x33333333)
+  return ((n + (n >> 4) & 0xF0F0F0F) * 0x1010101) >> 24
+}
+
+function jsValueToWasmName(x) {
+    if (typeof x == "number") {
+        if (x == 0) return 1 / x < 0 ? "-0" : "0";
+        if (isNaN(x)) return "+nan";
+        if (!isFinite(x)) return (x < 0 ? "-" : "+") + "inf";
+    }
+    return x;
+}
+
+// For each input array, a set of arrays of the proper length for v128, with
+// values in range but possibly of the wrong signedness (eg, for Int8Array, 128
+// is in range but is really -128).  Also a unary operator `rectify` that
+// transforms the value to the proper sign and bitwidth.
+
+Int8Array.inputs = [iota(16).map((x) => (x+1) * (x % 3 == 0 ? -1 : 1)),
+                    iota(16).map((x) => (x*2+3) * (x % 3 == 1 ? -1 : 1)),
+                    [1,2,128,127,1,4,128,127,1,2,129,125,1,2,254,0],
+                    [2,1,127,128,5,1,127,128,2,1,126,130,2,1,1,255],
+                    iota(16).map((x) => ((x + 37) * 8 + 12) % 256),
+                    iota(16).map((x) => ((x + 12) * 4 + 9) % 256)];
+Int8Array.rectify = (x) => sign_extend(x,8);
+Int8Array.layoutName = 'i8x16';
+
+Uint8Array.inputs = Int8Array.inputs;
+Uint8Array.rectify = (x) => zero_extend(x,8);
+Uint8Array.layoutName = 'i8x16';
+
+Int16Array.inputs = [iota(8).map((x) => (x+1) * (x % 3 == 0 ? -1 : 1)),
+                     iota(8).map((x) => (x*2+3) * (x % 3 == 1 ? -1 : 1)),
+                     [1,2,32768,32767,1,4,32768,32767],
+                     [2,1,32767,32768,5,1,32767,32768],
+                     [1,2,128,127,1,4,128,127].map((x) => (x << 8) + x*2),
+                     [2,1,127,128,1,1,128,128].map((x) => (x << 8) + x*3)];
+Int16Array.rectify = (x) => sign_extend(x,16);
+Int16Array.layoutName = 'i16x8';
+
+Uint16Array.inputs = Int16Array.inputs;
+Uint16Array.rectify = (x) => zero_extend(x,16);
+Uint16Array.layoutName = 'i16x8';
+
+Int32Array.inputs = [iota(4).map((x) => (x+1) * (x % 3 == 0 ? -1 : 1)),
+                     iota(4).map((x) => (x*2+3) * (x % 3 == 1 ? -1 : 1)),
+                     [1,2,32768 << 16,32767 << 16],
+                     [2,1,32767 << 16,32768 << 16],
+                     [1,2,128,127].map((x) => (x << 24) + (x << 8) + x*3),
+                     [2,1,127,128].map((x) => (x << 24) + (x << 8) + x*4)];
+Int32Array.rectify = (x) => sign_extend(x,32);
+Int32Array.layoutName = 'i32x4';
+
+Uint32Array.inputs = Int32Array.inputs;
+Uint32Array.rectify = (x) => zero_extend(x,32);
+Uint32Array.layoutName = 'i32x4';
+
+BigInt64Array.inputs = [[1,2],[2,1],[-1,-2],[-2,-1],[2n ** 32n, 2n ** 32n - 5n],
+                        [(2n ** 38n) / 5n, (2n ** 41n) / 7n],
+                        [-((2n ** 38n) / 5n), (2n ** 41n) / 7n]];
+BigInt64Array.rectify = (x) => BigInt(x);
+BigInt64Array.layoutName = 'i64x2';
+
+Float32Array.inputs = [[1, -1, 1e10, -1e10],
+                       [-1, -2, -1e10, 1e10],
+                       [5.1, -1.1, -4.3, -0],
+                       ...permute([1, -10, NaN, Infinity])];
+Float32Array.rectify = (x) => Math.fround(x);
+Float32Array.layoutName = 'f32x4';
+
+Float64Array.inputs = Float32Array.inputs.map((x) => x.slice(0, 2))
+Float64Array.rectify = (x) => x;
+Float64Array.layoutName = 'f64x2';
+
+// Tidy up all the inputs
+for ( let A of [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, BigInt64Array,
+                Float32Array, Float64Array]) {
+    A.inputs = A.inputs.map((xs) => xs.map(A.rectify));
+}
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops0.js b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops0.js
new file mode 100644
index 0000000000..f3406ac44a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops0.js
@@ -0,0 +1,7 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Do not include these in the preamble, they must be loaded after lib/wasm.js
+load(scriptdir + "ad-hack-preamble.js")
+load(scriptdir + "ad-hack-binop-preamble.js")
+
+runSimpleBinopTest(0, 3);
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops1.js b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops1.js
new file mode 100644
index 0000000000..e6d6f7e2fc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops1.js
@@ -0,0 +1,7 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Do not include these in the preamble, they must be loaded after lib/wasm.js
+load(scriptdir + "ad-hack-preamble.js")
+load(scriptdir + "ad-hack-binop-preamble.js")
+
+runSimpleBinopTest(1, 3);
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops2.js b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops2.js
new file mode 100644
index 0000000000..a196aa28fc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-binops2.js
@@ -0,0 +1,7 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Do not include these in the preamble, they must be loaded after lib/wasm.js
+load(scriptdir + "ad-hack-preamble.js")
+load(scriptdir + "ad-hack-binop-preamble.js")
+
+runSimpleBinopTest(2, 3);
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack-simple-unops.js b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-unops.js
new file mode 100644
index 0000000000..6e562a97a1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack-simple-unops.js
@@ -0,0 +1,122 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Do not include this in the preamble, it must be loaded after lib/wasm.js
+load(scriptdir + "ad-hack-preamble.js")
+
+// Simple unary operators.  Place parameter in memory at offset 16,
+// read the result at offset 0.
+
+function expandConstantUnopInputs(op, memtype, inputs) {
+    let s = '';
+    let ident = 0;
+    for ( let a of inputs ) {
+        let constval = `${memtype.layoutName} ${a.map(jsValueToWasmName).join(' ')}`;
+        s += `
+    (func (export "run_const${ident}")
+      (v128.store (i32.const 0)
+        (${op} (v128.const ${constval}))))
+`;
+        ident++;
+    }
+    return s;
+}
+
+function insAndMemUnop(op, memtype, resultmemtype, inputs) {
+    var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+
+    (func (export "run")
+      (v128.store (i32.const 0)
+        (call $doit (v128.load (i32.const 16)))))
+
+    (func $doit (param $a v128) (result v128)
+      (${op} (local.get $a)))
+
+    ${expandConstantUnopInputs(op, memtype, inputs)})`);
+    var mem = new memtype(ins.exports.mem.buffer);
+    var resultmem = !resultmemtype || memtype == resultmemtype ? mem : new resultmemtype(ins.exports.mem.buffer);
+    return [ins, mem, resultmem];
+}
+
+function ineg(bits) { return (a) => sign_extend(!a ? a : -a,bits) }
+function iabs(bits) { return (a) => zero_extend(a < 0 ? -a : a, bits) }
+function fneg(a) { return -a }
+function fabs(a) { return Math.abs(a) }
+function fsqrt(a) { return Math.fround(Math.sqrt(Math.fround(a))) }
+function dsqrt(a) { return Math.sqrt(a) }
+function bitnot(a) { return (~a) & 255 }
+function ffloor(x) { return Math.fround(Math.floor(x)) }
+function fceil(x) { return Math.fround(Math.ceil(x)) }
+function ftrunc(x) { return Math.fround(Math.sign(x)*Math.floor(Math.abs(x))) }
+function fnearest(x) { return Math.fround(Math.round(x)) }
+function dfloor(x) { return Math.floor(x) }
+function dceil(x) { return Math.ceil(x) }
+function dtrunc(x) { return Math.sign(x)*Math.floor(Math.abs(x)) }
+function dnearest(x) { return Math.round(x) }
+
+for ( let [op, memtype, rop, resultmemtype] of
+      [['i8x16.neg', Int8Array, ineg(8)],
+       ['i16x8.neg', Int16Array, ineg(16)],
+       ['i32x4.neg', Int32Array, ineg(32)],
+       ['i64x2.neg', BigInt64Array, ineg(64)],
+       ['i8x16.abs', Int8Array, iabs(8), Uint8Array],
+       ['i16x8.abs', Int16Array, iabs(16), Uint16Array],
+       ['i32x4.abs', Int32Array, iabs(32), Uint32Array],
+       ['f32x4.neg', Float32Array, fneg],
+       ['f64x2.neg', Float64Array, fneg],
+       ['f32x4.abs', Float32Array, fabs],
+       ['f64x2.abs', Float64Array, fabs],
+       ['f32x4.sqrt', Float32Array, fsqrt],
+       ['f64x2.sqrt', Float64Array, dsqrt],
+       ['f32x4.ceil', Float32Array, fceil],
+       ['f32x4.floor', Float32Array, ffloor],
+       ['f32x4.trunc', Float32Array, ftrunc],
+       ['f32x4.nearest', Float32Array, fnearest],
+       ['f64x2.ceil', Float64Array, dceil],
+       ['f64x2.floor', Float64Array, dfloor],
+       ['f64x2.trunc', Float64Array, dtrunc],
+       ['f64x2.nearest', Float64Array, dnearest],
+       ['v128.not', Uint8Array, bitnot],
+      ])
+{
+    let [ins, mem, resultmem] = insAndMemUnop(op, memtype, resultmemtype, memtype.inputs);
+    let len = 16/memtype.BYTES_PER_ELEMENT;
+    let xs = iota(len);
+    let zero = xs.map(_ => 0);
+    let bitsForF32 = memtype == Float32Array ? new Uint32Array(mem.buffer) : null;
+    let bitsForF64 = memtype == Float64Array ? new BigInt64Array(mem.buffer) : null;
+
+    function testIt(a, r) {
+        set(mem, len, a);
+        ins.exports.run();
+        assertSame(get(resultmem, 0, len), r);
+
+        // Test signalling NaN superficially by replacing QNaN inputs with SNaN
+        if (bitsForF32 != null && a.some(isNaN)) {
+            a.forEach((x, i) => { if (isNaN(x)) { bitsForF32[len+i] = 0x7FA0_0000; } });
+            ins.exports.run();
+            assertSame(get(resultmem, 0, len), r);
+        }
+        if (bitsForF64 != null && a.some(isNaN)) {
+            a.forEach((x, i) => { if (isNaN(x)) { bitsForF64[len+i] = 0x7FF4_0000_0000_0000n; } });
+            ins.exports.run();
+            assertSame(get(resultmem, 0, len), r);
+        }
+    }
+
+    function testConstIt(i,r) {
+        set(resultmem, 0, zero);
+        ins.exports["run_const" + i]();
+        assertSame(get(resultmem, 0, len), r);
+    }
+
+    let i = 0;
+    for (let a of memtype.inputs) {
+        let r = xs.map((i) => rop(a[i]));
+        testIt(a, r);
+        testConstIt(i, r);
+        i++;
+    }
+}
+
diff --git a/js/src/jit-test/tests/wasm/simd/ad-hack.js b/js/src/jit-test/tests/wasm/simd/ad-hack.js
new file mode 100644
index 0000000000..b64b11cf52
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ad-hack.js
@@ -0,0 +1,1747 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Ad-hoc test cases used during development.  Generally these are ordered from
+// easier toward harder.
+//
+// The test cases here are usually those that require some special processing.
+// Simple binary operators (v128 x v128 -> v128) and unary operators (v128 ->
+// v128) are tested in ad-hack-simple-binops*.js and ad-hack-simple-unops.js.
+
+// Do not include this in the preamble, it must be loaded after lib/wasm.js
+load(scriptdir + "ad-hack-preamble.js")
+
+// v128.store
+// oob store
+// v128.const
+
+for ( let offset of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) {
+    var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "f") (param $loc i32)
+      (v128.store offset=${offset} (local.get $loc) (v128.const i32x4 ${1+offset} 2 3 ${4+offset*2}))))`);
+    var mem8 = new Uint8Array(ins.exports.mem.buffer);
+    ins.exports.f(160);
+    assertSame(getUnaligned(mem8, 4, 160 + offset, 4), [1+offset, 2, 3, 4+offset*2]);
+
+    // OOB write should trap
+    assertErrorMessage(() => ins.exports.f(65536-15),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/)
+
+    // Ensure that OOB writes don't write anything: moved to simd-partial-oob-store.js
+}
+
+// v128.load
+// oob load
+// v128.store
+// temp register
+
+for ( let offset of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) {
+    var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "copy") (param $dest i32) (param $src i32)
+      (v128.store (local.get $dest) (v128.load offset=${offset} (local.get $src)))))`);
+    var mem32 = new Uint32Array(ins.exports.mem.buffer);
+    var mem8 = new Uint8Array(ins.exports.mem.buffer);
+    setUnaligned(mem8, 4, 4*4 + offset, [8+offset, 10, 12, 14+offset*2]);
+    ins.exports.copy(40*4, 4*4);
+    assertSame(get(mem32, 40, 4), [8+offset, 10, 12, 14+offset*2]);
+    assertErrorMessage(() => ins.exports.copy(40*4, 65536-15),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/);
+}
+
+// call [with register params]
+// parameters [in registers]
+// return [with register values]
+// locals
+//
+// local.get
+// local.set
+// v128.const
+// v128.store
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $g (param $param v128) (result v128)
+      (local $tmp v128)
+      (local.set $tmp (local.get $param))
+      (local.get $tmp))
+    (func (export "f")
+      (v128.store (i32.const 160) (call $g (v128.const i32x4 1 2 3 4)))))`);
+var mem = new Uint32Array(ins.exports.mem.buffer);
+ins.exports.f();
+assertSame(get(mem, 40, 4), [1, 2, 3, 4]);
+
+// Same test but with local.tee
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $g (param $param v128) (result v128)
+      (local $tmp v128)
+      (local.tee $tmp (local.get $param)))
+    (func (export "f")
+      (v128.store (i32.const 160) (call $g (v128.const i32x4 1 2 3 4)))))`);
+var mem = new Uint32Array(ins.exports.mem.buffer);
+ins.exports.f();
+assertSame(get(mem, 40, 4), [1, 2, 3, 4]);
+
+// Locals that end up on the stack.  Try to create unaligned placement (in the
+// baseline compiler anyway) by inserting i32 locals before or after and
+// inbetween the v128 ones and by having so many locals that we run out of
+// registers.
+
+var nlocals = 64;
+for ( let start of [0, 1]) {
+    let decl = "";
+    let set = "";
+    let sum = "(v128.const i32x4 0 0 0 0)";
+    var res = [0,0,0,0];
+    var locno = start;
+    for ( let i=start ; i < start + nlocals ; i++ ) {
+        decl += "(local v128) ";
+        set += `(local.set ${locno} (v128.const i32x4 ${i} ${i+1} ${i+2} ${i+3})) `;
+        sum = `(i32x4.add ${sum} (local.get ${locno}))`;
+        locno++;
+        res[0] += i;
+        res[1] += i+1;
+        res[2] += i+2;
+        res[3] += i+3;
+        if ((i % 5) == 3) {
+            decl += "(local i32) ";
+            locno++;
+        }
+    }
+    if (start)
+        decl = "(local i32) " + decl;
+    else
+        decl += "(local i32) ";
+    var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $g (result v128)
+      ${decl}
+      ${set}
+      ${sum})
+    (func (export "f")
+      (v128.store (i32.const 160) (call $g))))`);
+
+    var mem = new Uint32Array(ins.exports.mem.buffer);
+    ins.exports.f();
+    assertSame(get(mem, 40, 4), res);
+}
+
+// Ditto parameters.  This is like the case above but values are passed rather
+// than set.
+//
+// call
+// call_indirect
+
+var nlocals = 64;
+for ( let start of [0, 1]) {
+    let decl = "";
+    let pass = "";
+    let sum = "(v128.const i32x4 0 0 0 0)";
+    var res = [0,0,0,0];
+    var locno = start;
+    for ( let i=start ; i < start + nlocals ; i++ ) {
+        decl += "(param v128) ";
+        pass += `(v128.const i32x4 ${i} ${i+1} ${i+2} ${i+3}) `;
+        sum = `(i32x4.add ${sum} (local.get ${locno}))`;
+        locno++;
+        res[0] += i;
+        res[1] += i+1;
+        res[2] += i+2;
+        res[3] += i+3;
+        if ((i % 5) == 3) {
+            decl += "(param i32) ";
+            pass += "(i32.const 0) ";
+            locno++;
+        }
+    }
+    if (start) {
+        decl = "(param i32) " + decl;
+        pass = "(i32.const 0) " + pass;
+    } else {
+        decl += "(param i32) ";
+        pass += "(i32.const 0) ";
+    }
+    var txt = `
+  (module
+    (memory (export "mem") 1 1)
+    (type $t1 (func ${decl} (result v128)))
+    (table funcref (elem $h))
+    (func $g ${decl} (result v128)
+      ${sum})
+    (func (export "f1")
+      (v128.store (i32.const 160) (call $g ${pass})))
+    (func $h ${decl} (result v128)
+      ${sum})
+    (func (export "f2")
+      (v128.store (i32.const 512) (call_indirect (type $t1) ${pass} (i32.const 0)))))`;
+    var ins = wasmEvalText(txt);
+
+    var mem = new Uint32Array(ins.exports.mem.buffer);
+    ins.exports.f1();
+    assertSame(get(mem, 40, 4), res);
+    ins.exports.f2();
+    assertSame(get(mem, 128, 4), res);
+}
+
+// Widening integer dot product
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "run")
+      (v128.store (i32.const 0)
+        (i32x4.dot_i16x8_s (v128.load (i32.const 16)) (v128.load (i32.const 32))))))`);
+
+var xs = [5, 1, -4, 2, 20, -15, 12, 3];
+var ys = [6, 0, -7, 3, 8, -1, -3, 7];
+var ans = [xs[0]*ys[0] + xs[1]*ys[1],
+           xs[2]*ys[2] + xs[3]*ys[3],
+           xs[4]*ys[4] + xs[5]*ys[5],
+           xs[6]*ys[6] + xs[7]*ys[7]];
+
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+set(mem16, 8, xs);
+set(mem16, 16, ys);
+ins.exports.run();
+var result = get(mem32, 0, 4);
+assertSame(result, ans);
+
+// Splat, with and without constants (different code paths in ion)
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "splat_i8x16") (param $src i32)
+      (v128.store (i32.const 0) (i8x16.splat (local.get $src))))
+    (func (export "csplat_i8x16")
+      (v128.store (i32.const 0) (i8x16.splat (i32.const 37))))
+    (func (export "splat_i16x8") (param $src i32)
+      (v128.store (i32.const 0) (i16x8.splat (local.get $src))))
+    (func (export "csplat_i16x8")
+      (v128.store (i32.const 0) (i16x8.splat (i32.const 1175))))
+    (func (export "splat_i32x4") (param $src i32)
+      (v128.store (i32.const 0) (i32x4.splat (local.get $src))))
+    (func (export "csplat_i32x4")
+      (v128.store (i32.const 0) (i32x4.splat (i32.const 127639))))
+    (func (export "splat_i64x2") (param $src i64)
+      (v128.store (i32.const 0) (i64x2.splat (local.get $src))))
+    (func (export "csplat_i64x2")
+      (v128.store (i32.const 0) (i64x2.splat (i64.const 0x1234_5678_4365))))
+    (func (export "splat_f32x4") (param $src f32)
+      (v128.store (i32.const 0) (f32x4.splat (local.get $src))))
+    (func (export "csplat_f32x4")
+      (v128.store (i32.const 0) (f32x4.splat (f32.const 9121.25))))
+    (func (export "splat_f64x2") (param $src f64)
+      (v128.store (i32.const 0) (f64x2.splat (local.get $src))))
+    (func (export "csplat_f64x2")
+      (v128.store (i32.const 0) (f64x2.splat (f64.const 26789.125))))
+)`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+ins.exports.splat_i8x16(3);
+assertSame(get(mem8, 0, 16), iota(16).map(_=>3));
+ins.exports.csplat_i8x16();
+assertSame(get(mem8, 0, 16), iota(16).map(_=>37));
+
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+ins.exports.splat_i16x8(976);
+assertSame(get(mem16, 0, 8), iota(8).map(_=>976));
+ins.exports.csplat_i16x8();
+assertSame(get(mem16, 0, 8), iota(8).map(_=>1175));
+
+var mem32 = new Uint32Array(ins.exports.mem.buffer);
+ins.exports.splat_i32x4(147812);
+assertSame(get(mem32, 0, 4), [147812, 147812, 147812, 147812]);
+ins.exports.csplat_i32x4();
+assertSame(get(mem32, 0, 4), [127639, 127639, 127639, 127639]);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+ins.exports.splat_i64x2(147812n);
+assertSame(get(mem64, 0, 2), [147812, 147812]);
+ins.exports.csplat_i64x2();
+assertSame(get(mem64, 0, 2), [0x1234_5678_4365n, 0x1234_5678_4365n]);
+
+var memf32 = new Float32Array(ins.exports.mem.buffer);
+ins.exports.splat_f32x4(147812.5);
+assertSame(get(memf32, 0, 4), [147812.5, 147812.5, 147812.5, 147812.5]);
+ins.exports.csplat_f32x4();
+assertSame(get(memf32, 0, 4), [9121.25, 9121.25, 9121.25, 9121.25]);
+
+var memf64 = new Float64Array(ins.exports.mem.buffer);
+ins.exports.splat_f64x2(147812.5);
+assertSame(get(memf64, 0, 2), [147812.5, 147812.5]);
+ins.exports.csplat_f64x2();
+assertSame(get(memf64, 0, 2), [26789.125, 26789.125]);
+
+// AnyTrue.  Ion constant folds, so test that too.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "anytrue_i8x16") (result i32)
+      (v128.any_true (v128.load (i32.const 16))))
+    (func (export "true_anytrue_i8x16") (result i32)
+      (v128.any_true (v128.const i8x16 0 0 8 0 0 0 0 0 0 0 0 0 0 0 0 0)))
+    (func (export "false_anytrue_i8x16") (result i32)
+      (v128.any_true (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))`);
+
+var mem = new Uint8Array(ins.exports.mem.buffer);
+set(mem, 16, iota(16).map((_) => 0));
+assertEq(ins.exports.anytrue_i8x16(), 0);
+
+for ( let dope of [1, 7, 32, 195 ] ) {
+    set(mem, 16, iota(16).map((x) => x == 7 ? dope : 0));
+    assertEq(ins.exports.anytrue_i8x16(), 1);
+}
+
+assertEq(ins.exports.true_anytrue_i8x16(), 1);
+assertEq(ins.exports.false_anytrue_i8x16(), 0);
+
+// AllTrue.  Ion constant folds, so test that too.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "alltrue_i8x16") (result i32)
+      (i8x16.all_true (v128.load (i32.const 16))))
+    (func (export "true_alltrue_i8x16") (result i32)
+      (i8x16.all_true (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)))
+    (func (export "false_alltrue_i8x16") (result i32)
+      (i8x16.all_true (v128.const i8x16 1 2 3 4 5 6 0 8 9 10 11 12 13 14 15 16)))
+    (func (export "alltrue_i16x8") (result i32)
+      (i16x8.all_true (v128.load (i32.const 16))))
+    (func (export "true_alltrue_i16x8") (result i32)
+      (i16x8.all_true (v128.const i16x8 1 2 3 4 5 6 7 8)))
+    (func (export "false_alltrue_i16x8") (result i32)
+      (i16x8.all_true (v128.const i16x8 1 2 3 4 5 0 7 8)))
+    (func (export "alltrue_i32x4") (result i32)
+      (i32x4.all_true (v128.load (i32.const 16))))
+    (func (export "true_alltrue_i32x4") (result i32)
+      (i32x4.all_true (v128.const i32x4 1 2 3 4)))
+    (func (export "false_alltrue_i32x4") (result i32)
+      (i32x4.all_true (v128.const i32x4 1 2 3 0))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+var mem32 = new Uint32Array(ins.exports.mem.buffer);
+
+set(mem8, 16, iota(16).map((_) => 0));
+assertEq(ins.exports.alltrue_i8x16(), 0);
+assertEq(ins.exports.alltrue_i16x8(), 0);
+assertEq(ins.exports.alltrue_i32x4(), 0);
+
+set(mem8, 16, iota(16).map((_) => 1));
+assertEq(ins.exports.alltrue_i8x16(), 1);
+
+set(mem16, 8, iota(8).map((_) => 1));
+assertEq(ins.exports.alltrue_i16x8(), 1);
+
+set(mem32, 4, iota(4).map((_) => 1));
+assertEq(ins.exports.alltrue_i32x4(), 1);
+
+for ( let dope of [1, 7, 32, 195 ] ) {
+    set(mem8, 16, iota(16).map((x) => x == 7 ? 0 : dope));
+    assertEq(ins.exports.alltrue_i8x16(), 0);
+
+    set(mem16, 8, iota(8).map((x) => x == 4 ? 0 : dope));
+    assertEq(ins.exports.alltrue_i16x8(), 0);
+
+    set(mem32, 4, iota(4).map((x) => x == 2 ? 0 : dope));
+    assertEq(ins.exports.alltrue_i32x4(), 0);
+}
+
+assertEq(ins.exports.true_alltrue_i8x16(), 1);
+assertEq(ins.exports.false_alltrue_i8x16(), 0);
+assertEq(ins.exports.true_alltrue_i16x8(), 1);
+assertEq(ins.exports.false_alltrue_i16x8(), 0);
+assertEq(ins.exports.true_alltrue_i32x4(), 1);
+assertEq(ins.exports.false_alltrue_i32x4(), 0);
+
+// Bitmask.  Ion constant folds, so test that too.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "bitmask_i8x16") (result i32)
+      (i8x16.bitmask (v128.load (i32.const 16))))
+    (func (export "const_bitmask_i8x16") (result i32)
+      (i8x16.bitmask (v128.const i8x16 0x80 0x7f 0xff 0x33 0x42 0x98 0x01 0x00
+                                       0x31 0xcc 0xdd 0x12 0xf0 0x40 0x02 0xa0)))
+    (func (export "bitmask_i16x8") (result i32)
+      (i16x8.bitmask (v128.load (i32.const 16))))
+    (func (export "const_bitmask_i16x8") (result i32)
+      (i16x8.bitmask (v128.const i16x8 0x7f80 0xff33 0x9842 0x0001 0xcc31 0x12dd 0x40f0 0xa002)))
+    (func (export "bitmask_i32x4") (result i32)
+      (i32x4.bitmask (v128.load (i32.const 16))))
+    (func (export "const_bitmask_i32x4") (result i32)
+      (i32x4.bitmask (v128.const i32x4 0xff337f80 0x00019842 0xcc3112dd 0xa00240f0))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+var mem32 = new Uint32Array(ins.exports.mem.buffer);
+
+set(mem8, 16, iota(16).map((_) => 0));
+assertEq(ins.exports.bitmask_i8x16(), 0);
+assertEq(ins.exports.bitmask_i16x8(), 0);
+assertEq(ins.exports.bitmask_i32x4(), 0);
+
+set(mem8, 16, iota(16).map((_) => 0x80));
+assertEq(ins.exports.bitmask_i8x16(), 0xFFFF);
+
+set(mem8, 16, iota(16).map((_) => 0x7F));
+assertEq(ins.exports.bitmask_i8x16(), 0);
+
+set(mem8, 16, iota(16).map((i) => popcount(i) == 1 ? 0x80 : 0));
+assertEq(ins.exports.bitmask_i8x16(), (1 << 1) | (1 << 2) | (1 << 4) | (1 << 8));
+
+assertEq(ins.exports.const_bitmask_i8x16(), 0x9625);
+
+set(mem16, 8, iota(8).map((i) => 0x8000))
+assertEq(ins.exports.bitmask_i16x8(), 0xFF)
+
+set(mem16, 8, iota(8).map((i) => 0x7FFF))
+assertEq(ins.exports.bitmask_i16x8(), 0)
+
+set(mem16, 8, iota(8).map((i) => popcount(i) == 1 ? 0x8000 : 0))
+assertEq(ins.exports.bitmask_i16x8(), (1 << 1) | (1 << 2) | (1 << 4));
+
+assertEq(ins.exports.const_bitmask_i16x8(), 0x96);
+
+set(mem32, 4, iota(4).map((_) => 0x80000000))
+assertEq(ins.exports.bitmask_i32x4(), 0xF);
+
+set(mem32, 4, iota(4).map((_) => 0x7FFFFFFF))
+assertEq(ins.exports.bitmask_i32x4(), 0);
+
+set(mem32, 4, iota(4).map((i) => popcount(i) == 1 ? 0x80000000 : 0))
+assertEq(ins.exports.bitmask_i32x4(), (1 << 1) | (1 << 2));
+
+assertEq(ins.exports.const_bitmask_i32x4(), 0xd);
+
+// Shifts
+//
+// lhs is v128 in memory
+// rhs is i32 (passed directly)
+// result is v128 in memory
+
+function shr(count, width) {
+    return (v) => {
+        if (count == 0)
+            return v;
+        if (width == 64) {
+            if (v < 0) {
+                // This basically mirrors what the SIMD code does, so if there's
+                // a bug there then there's a bug here too.  Seems OK though.
+                let s = 0x1_0000_0000_0000_0000n + BigInt(v);
+                let t = s / (1n << BigInt(count));
+                let u = ((1n << BigInt(count)) - 1n) * (2n ** BigInt(64-count));
+                let w = t + u;
+                return w - 0x1_0000_0000_0000_0000n;
+            }
+            return BigInt(v) / (1n << BigInt(count));
+        } else {
+            let mask = (width == 32) ? -1 : ((1 << width) - 1);
+            return (sign_extend(v, width) >> count) & mask;
+        }
+    }
+}
+
+function shru(count, width) {
+    if (width == 64) {
+        return (v) => {
+            if (count == 0)
+                return v;
+            if (v < 0) {
+                v = 0x1_0000_0000_0000_0000n + BigInt(v);
+            }
+            return BigInt(v) / (1n << BigInt(count));
+        }
+    } else {
+        return (v) => {
+            let mask = (width == 32) ? -1 : ((1 << width) - 1);
+            return (v >>> count) & mask;
+        }
+    }
+}
+
+var constantI8Shifts = "";
+for ( let i of iota(10).concat([-7]) ) {
+    constantI8Shifts += `
+    (func (export "shl_i8x16_${i}")
+      (v128.store (i32.const 0) (i8x16.shl (v128.load (i32.const 16)) (i32.const ${i}))))
+    (func (export "shr_i8x16_${i}")
+      (v128.store (i32.const 0) (i8x16.shr_s (v128.load (i32.const 16)) (i32.const ${i}))))
+    (func (export "shr_u8x16_${i}")
+      (v128.store (i32.const 0) (i8x16.shr_u (v128.load (i32.const 16)) (i32.const ${i}))))`;
+}
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "shl_i8x16") (param $count i32)
+      (v128.store (i32.const 0) (i8x16.shl (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_i8x16") (param $count i32)
+      (v128.store (i32.const 0) (i8x16.shr_s (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_u8x16") (param $count i32)
+      (v128.store (i32.const 0) (i8x16.shr_u (v128.load (i32.const 16)) (local.get $count))))
+    ${constantI8Shifts}
+    (func (export "shl_i16x8") (param $count i32)
+      (v128.store (i32.const 0) (i16x8.shl (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shl_i16x8_3")
+      (v128.store (i32.const 0) (i16x8.shl (v128.load (i32.const 16)) (i32.const 3))))
+    (func (export "shl_i16x8_15")
+      (v128.store (i32.const 0) (i16x8.shl (v128.load (i32.const 16)) (i32.const 15))))
+    (func (export "shl_i16x8_16")
+      (v128.store (i32.const 0) (i16x8.shl (v128.load (i32.const 16)) (i32.const 16))))
+    (func (export "shl_i16x8_-15")
+      (v128.store (i32.const 0) (i16x8.shl (v128.load (i32.const 16)) (i32.const -15))))
+    (func (export "shr_i16x8") (param $count i32)
+      (v128.store (i32.const 0) (i16x8.shr_s (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_i16x8_3")
+      (v128.store (i32.const 0) (i16x8.shr_s (v128.load (i32.const 16)) (i32.const 3))))
+    (func (export "shr_i16x8_15")
+      (v128.store (i32.const 0) (i16x8.shr_s (v128.load (i32.const 16)) (i32.const 15))))
+    (func (export "shr_i16x8_16")
+      (v128.store (i32.const 0) (i16x8.shr_s (v128.load (i32.const 16)) (i32.const 16))))
+    (func (export "shr_i16x8_-15")
+      (v128.store (i32.const 0) (i16x8.shr_s (v128.load (i32.const 16)) (i32.const -15))))
+    (func (export "shr_u16x8") (param $count i32)
+      (v128.store (i32.const 0) (i16x8.shr_u (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_u16x8_3")
+      (v128.store (i32.const 0) (i16x8.shr_u (v128.load (i32.const 16)) (i32.const 3))))
+    (func (export "shr_u16x8_15")
+      (v128.store (i32.const 0) (i16x8.shr_u (v128.load (i32.const 16)) (i32.const 15))))
+    (func (export "shr_u16x8_16")
+      (v128.store (i32.const 0) (i16x8.shr_u (v128.load (i32.const 16)) (i32.const 16))))
+    (func (export "shr_u16x8_-15")
+      (v128.store (i32.const 0) (i16x8.shr_u (v128.load (i32.const 16)) (i32.const -15))))
+    (func (export "shl_i32x4") (param $count i32)
+      (v128.store (i32.const 0) (i32x4.shl (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shl_i32x4_12")
+      (v128.store (i32.const 0) (i32x4.shl (v128.load (i32.const 16)) (i32.const 12))))
+    (func (export "shl_i32x4_31")
+      (v128.store (i32.const 0) (i32x4.shl (v128.load (i32.const 16)) (i32.const 31))))
+    (func (export "shl_i32x4_32")
+      (v128.store (i32.const 0) (i32x4.shl (v128.load (i32.const 16)) (i32.const 32))))
+    (func (export "shl_i32x4_-27")
+      (v128.store (i32.const 0) (i32x4.shl (v128.load (i32.const 16)) (i32.const -27))))
+    (func (export "shr_i32x4") (param $count i32)
+      (v128.store (i32.const 0) (i32x4.shr_s (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_i32x4_12")
+      (v128.store (i32.const 0) (i32x4.shr_s (v128.load (i32.const 16)) (i32.const 12))))
+    (func (export "shr_i32x4_31")
+      (v128.store (i32.const 0) (i32x4.shr_s (v128.load (i32.const 16)) (i32.const 31))))
+    (func (export "shr_i32x4_32")
+      (v128.store (i32.const 0) (i32x4.shr_s (v128.load (i32.const 16)) (i32.const 32))))
+    (func (export "shr_i32x4_-27")
+      (v128.store (i32.const 0) (i32x4.shr_s (v128.load (i32.const 16)) (i32.const -27))))
+    (func (export "shr_u32x4") (param $count i32)
+      (v128.store (i32.const 0) (i32x4.shr_u (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_u32x4_12")
+      (v128.store (i32.const 0) (i32x4.shr_u (v128.load (i32.const 16)) (i32.const 12))))
+    (func (export "shr_u32x4_31")
+      (v128.store (i32.const 0) (i32x4.shr_u (v128.load (i32.const 16)) (i32.const 31))))
+    (func (export "shr_u32x4_32")
+      (v128.store (i32.const 0) (i32x4.shr_u (v128.load (i32.const 16)) (i32.const 32))))
+    (func (export "shr_u32x4_-27")
+      (v128.store (i32.const 0) (i32x4.shr_u (v128.load (i32.const 16)) (i32.const -27))))
+    (func (export "shl_i64x2") (param $count i32)
+      (v128.store (i32.const 0) (i64x2.shl (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shl_i64x2_27")
+      (v128.store (i32.const 0) (i64x2.shl (v128.load (i32.const 16)) (i32.const 27))))
+    (func (export "shl_i64x2_63")
+      (v128.store (i32.const 0) (i64x2.shl (v128.load (i32.const 16)) (i32.const 63))))
+    (func (export "shl_i64x2_64")
+      (v128.store (i32.const 0) (i64x2.shl (v128.load (i32.const 16)) (i32.const 64))))
+    (func (export "shl_i64x2_-231")
+      (v128.store (i32.const 0) (i64x2.shl (v128.load (i32.const 16)) (i32.const -231))))
+    (func (export "shr_i64x2") (param $count i32)
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_i64x2_27")
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (i32.const 27))))
+    (func (export "shr_i64x2_45")
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (i32.const 45))))
+    (func (export "shr_i64x2_63")
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (i32.const 63))))
+    (func (export "shr_i64x2_64")
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (i32.const 64))))
+    (func (export "shr_i64x2_-231")
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (i32.const -231))))
+    (func (export "shr_i64x2_-1")
+      (v128.store (i32.const 0) (i64x2.shr_s (v128.load (i32.const 16)) (i32.const -1))))
+    (func (export "shr_u64x2") (param $count i32)
+      (v128.store (i32.const 0) (i64x2.shr_u (v128.load (i32.const 16)) (local.get $count))))
+    (func (export "shr_u64x2_27")
+      (v128.store (i32.const 0) (i64x2.shr_u (v128.load (i32.const 16)) (i32.const 27))))
+    (func (export "shr_u64x2_63")
+      (v128.store (i32.const 0) (i64x2.shr_u (v128.load (i32.const 16)) (i32.const 63))))
+    (func (export "shr_u64x2_64")
+      (v128.store (i32.const 0) (i64x2.shr_u (v128.load (i32.const 16)) (i32.const 64))))
+    (func (export "shr_u64x2_-231")
+      (v128.store (i32.const 0) (i64x2.shr_u (v128.load (i32.const 16)) (i32.const -231)))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var as = [1, 2, 4, 8, 16, 32, 64, 128, 129, 130, 132, 136, 144, 160, 192, 255];
+
+set(mem8, 16, as);
+
+for (let [meth,op] of [["shl_i8x16",shl], ["shr_i8x16",shr], ["shr_u8x16",shru]]) {
+    for ( let i=0 ; i < 8 ; i++ ) {
+        ins.exports[meth](i);
+        assertSame(get(mem8, 0, 16), as.map(op(i, 8)))
+        ins.exports[meth + "_" + i]();
+        assertSame(get(mem8, 0, 16), as.map(op(i, 8)))
+    }
+
+    ins.exports[meth](1);
+    let a = get(mem8, 0, 16);
+    ins.exports[meth](9);
+    let b = get(mem8, 0, 16);
+    assertSame(a, b);
+    ins.exports[meth](-7);
+    let c = get(mem8, 0, 16);
+    assertSame(a, c);
+
+    ins.exports[meth + "_1"]();
+    let x = get(mem8, 0, 16);
+    ins.exports[meth + "_9"]();
+    let y = get(mem8, 0, 16);
+    ins.exports[meth + "_-7"]();
+    let z = get(mem8, 0, 16);
+    assertSame(x, y);
+    assertSame(x, z);
+}
+
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+var as = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000];
+set(mem16, 8, as)
+
+ins.exports.shl_i16x8(2);
+var res = get(mem16, 0, 8);
+assertSame(res, as.map(shl(2, 16)))
+
+ins.exports.shl_i16x8(18);      // Masked count
+assertSame(get(mem16, 0, 8), res);
+
+ins.exports.shl_i16x8(-14);      // Masked count
+assertSame(get(mem16, 0, 8), res);
+
+for ( let shift of [3, 15, 16, -15] ) {
+    ins.exports["shl_i16x8_" + shift]();
+    assertSame(get(mem16, 0, 8), as.map(shl(shift & 15, 16)))
+}
+
+ins.exports.shr_i16x8(1);
+var res = get(mem16, 0, 8);
+assertSame(res, as.map(shr(1, 16)))
+
+ins.exports.shr_i16x8(17);      // Masked count
+assertSame(get(mem16, 0, 8), res);
+
+ins.exports.shr_i16x8(-15);      // Masked count
+assertSame(get(mem16, 0, 8), res);
+
+for ( let shift of [3, 15, 16, -15] ) {
+    ins.exports["shr_i16x8_" + shift]();
+    assertSame(get(mem16, 0, 8), as.map(shr(shift & 15, 16)))
+}
+
+ins.exports.shr_u16x8(1);
+var res = get(mem16, 0, 8);
+assertSame(res, as.map(shru(1, 16)))
+
+ins.exports.shr_u16x8(17);      // Masked count
+assertSame(get(mem16, 0, 8), res);
+
+ins.exports.shr_u16x8(-15);      // Masked count
+assertSame(get(mem16, 0, 8), res);
+
+for ( let shift of [3, 15, 16, -15] ) {
+    ins.exports["shr_u16x8_" + shift]();
+    assertSame(get(mem16, 0, 8), as.map(shru(shift & 15, 16)))
+}
+
+var mem32 = new Uint32Array(ins.exports.mem.buffer);
+var as = [5152, 6768, 7074, 800811];
+
+set(mem32, 4, as)
+ins.exports.shl_i32x4(2);
+var res = get(mem32, 0, 4);
+assertSame(res, as.map(shl(2, 32)))
+
+ins.exports.shl_i32x4(34);      // Masked count
+assertSame(get(mem32, 0, 4), res);
+
+ins.exports.shl_i32x4(-30);      // Masked count
+assertSame(get(mem32, 0, 4), res);
+
+for ( let shift of [12, 31, 32, -27] ) {
+    ins.exports["shl_i32x4_" + shift]();
+    assertSame(get(mem32, 0, 4), as.map(shl(shift & 31, 32)).map(x => x>>>0))
+}
+
+ins.exports.shr_i32x4(1);
+var res = get(mem32, 0, 4);
+assertSame(res, as.map(shr(1, 32)))
+
+ins.exports.shr_i32x4(33);      // Masked count
+assertSame(get(mem32, 0, 4), res);
+
+ins.exports.shr_i32x4(-31);      // Masked count
+assertSame(get(mem32, 0, 4), res);
+
+for ( let shift of [12, 31, 32, -27] ) {
+    ins.exports["shr_i32x4_" + shift]();
+    assertSame(get(mem32, 0, 4), as.map(shr(shift & 31, 32)))
+}
+
+ins.exports.shr_u32x4(1);
+var res = get(mem32, 0, 4);
+assertSame(res, as.map(shru(1, 32)))
+
+ins.exports.shr_u32x4(33);      // Masked count
+assertSame(get(mem32, 0, 4), res);
+
+ins.exports.shr_u32x4(-31);      // Masked count
+assertSame(get(mem32, 0, 4), res);
+
+for ( let shift of [12, 31, 32, -27] ) {
+    ins.exports["shr_u32x4_" + shift]();
+    assertSame(get(mem32, 0, 4), as.map(shru(shift & 31, 32)))
+}
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+var as = [50515253, -616263];
+
+set(mem64, 2, as)
+ins.exports.shl_i64x2(2);
+var res = get(mem64, 0, 2);
+assertSame(res, as.map(shl(2, 64)))
+
+ins.exports.shl_i64x2(66);      // Masked count
+assertSame(get(mem64, 0, 2), res);
+
+ins.exports.shl_i64x2(-62);      // Masked count
+assertSame(get(mem64, 0, 2), res);
+
+for ( let shift of [27, 63, 64, -231] ) {
+    ins.exports["shl_i64x2_" + shift]();
+    assertSame(get(mem64, 0, 2), as.map(shl(shift & 63, 64)))
+}
+
+ins.exports.shr_u64x2(1);
+var res = get(mem64, 0, 2);
+assertSame(res, as.map(shru(1, 64)))
+
+ins.exports.shr_u64x2(65);      // Masked count
+assertSame(get(mem64, 0, 2), res);
+
+ins.exports.shr_u64x2(-63);      // Masked count
+assertSame(get(mem64, 0, 2), res);
+
+for ( let shift of [27, 63, 64, -231] ) {
+    ins.exports["shr_u64x2_" + shift]();
+    assertSame(get(mem64, 0, 2), as.map(shru(shift & 63, 64)))
+}
+
+ins.exports.shr_i64x2(2);
+var res = get(mem64, 0, 2);
+assertSame(res, as.map(shr(2, 64)))
+
+ins.exports.shr_i64x2(66);      // Masked count
+assertSame(get(mem64, 0, 2), res);
+
+ins.exports.shr_i64x2(-62);      // Masked count
+assertSame(get(mem64, 0, 2), res);
+
+// The ion code generator has multiple paths here, for < 32 and >= 32
+for ( let shift of [27, 45, 63, 64, -1, -231] ) {
+    ins.exports["shr_i64x2_" + shift]();
+    assertSame(get(mem64, 0, 2), as.map(shr(shift & 63, 64)))
+}
+
+// Narrow
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "narrow_i16x8_s")
+      (v128.store (i32.const 0) (i8x16.narrow_i16x8_s (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+    (func (export "narrow_i16x8_u")
+      (v128.store (i32.const 0) (i8x16.narrow_i16x8_u (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+    (func (export "narrow_i32x4_s")
+      (v128.store (i32.const 0) (i16x8.narrow_i32x4_s (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+    (func (export "narrow_i32x4_u")
+      (v128.store (i32.const 0) (i16x8.narrow_i32x4_u (v128.load (i32.const 16)) (v128.load (i32.const 32))))))`);
+
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+var mem8u = new Uint8Array(ins.exports.mem.buffer);
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+var mem16u = new Uint16Array(ins.exports.mem.buffer);
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+
+var as = [1, 267, 3987, 14523, 32768, 3, 312, 4876].map((x) => sign_extend(x, 16));
+var bs = [2, 312, 4876, 15987, 33777, 1, 267, 3987].map((x) => sign_extend(x, 16));
+
+set(mem16, 8, as);
+set(mem16, 16, bs);
+
+ins.exports.narrow_i16x8_s();
+var cs = as.concat(...bs).map((x) => signed_saturate(x, 8));
+assertSame(get(mem8, 0, 16), cs);
+
+ins.exports.narrow_i16x8_u();
+var cs = as.concat(...bs).map((x) => unsigned_saturate(x, 8));
+assertSame(get(mem8u, 0, 16), cs);
+
+var xs = [1, 3987, 14523, 32768].map((x) => x << 16).map((x) => sign_extend(x, 32));
+var ys = [2, 4876, 15987, 33777].map((x) => x << 16).map((x) => sign_extend(x, 32));
+
+set(mem32, 4, xs);
+set(mem32, 8, ys);
+
+ins.exports.narrow_i32x4_s();
+var cs = xs.concat(...ys).map((x) => signed_saturate(x, 16));
+assertSame(get(mem16, 0, 8), cs);
+
+ins.exports.narrow_i32x4_u();
+var cs = xs.concat(...ys).map((x) => unsigned_saturate(x, 16));
+assertSame(get(mem16u, 0, 8), cs);
+
+// Extend low/high
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "extend_low_i8x16_s")
+      (v128.store (i32.const 0) (i16x8.extend_low_i8x16_s (v128.load (i32.const 16)))))
+    (func (export "extend_high_i8x16_s")
+      (v128.store (i32.const 0) (i16x8.extend_high_i8x16_s (v128.load (i32.const 16)))))
+    (func (export "extend_low_i8x16_u")
+      (v128.store (i32.const 0) (i16x8.extend_low_i8x16_u (v128.load (i32.const 16)))))
+    (func (export "extend_high_i8x16_u")
+      (v128.store (i32.const 0) (i16x8.extend_high_i8x16_u (v128.load (i32.const 16)))))
+    (func (export "extend_low_i16x8_s")
+      (v128.store (i32.const 0) (i32x4.extend_low_i16x8_s (v128.load (i32.const 16)))))
+    (func (export "extend_high_i16x8_s")
+      (v128.store (i32.const 0) (i32x4.extend_high_i16x8_s (v128.load (i32.const 16)))))
+    (func (export "extend_low_i16x8_u")
+      (v128.store (i32.const 0) (i32x4.extend_low_i16x8_u (v128.load (i32.const 16)))))
+    (func (export "extend_high_i16x8_u")
+      (v128.store (i32.const 0) (i32x4.extend_high_i16x8_u (v128.load (i32.const 16))))))`);
+
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+var mem16u = new Uint16Array(ins.exports.mem.buffer);
+var mem8 =  new Int8Array(ins.exports.mem.buffer);
+var as = [0, 1, 192, 3, 205, 5, 6, 133, 8, 9, 129, 11, 201, 13, 14, 255];
+
+set(mem8, 16, as);
+
+ins.exports.extend_low_i8x16_s();
+assertSame(get(mem16, 0, 8), iota(8).map((n) => sign_extend(as[n], 8)));
+
+ins.exports.extend_high_i8x16_s();
+assertSame(get(mem16, 0, 8), iota(8).map((n) => sign_extend(as[n+8], 8)));
+
+ins.exports.extend_low_i8x16_u();
+assertSame(get(mem16u, 0, 8), iota(8).map((n) => zero_extend(as[n], 8)));
+
+ins.exports.extend_high_i8x16_u();
+assertSame(get(mem16u, 0, 8), iota(8).map((n) => zero_extend(as[n+8], 8)));
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var mem32u = new Uint32Array(ins.exports.mem.buffer);
+
+var as = [0, 1, 192, 3, 205, 5, 6, 133].map((x) => x << 8);
+
+set(mem16, 8, as);
+
+ins.exports.extend_low_i16x8_s();
+assertSame(get(mem32, 0, 4), iota(4).map((n) => sign_extend(as[n], 16)));
+
+ins.exports.extend_high_i16x8_s();
+assertSame(get(mem32, 0, 4), iota(4).map((n) => sign_extend(as[n+4], 16)));
+
+ins.exports.extend_low_i16x8_u();
+assertSame(get(mem32u, 0, 4), iota(4).map((n) => zero_extend(as[n], 16)));
+
+ins.exports.extend_high_i16x8_u();
+assertSame(get(mem32u, 0, 4), iota(4).map((n) => zero_extend(as[n+4], 16)));
+
+
+// Extract lane.  Ion constant folds, so test that too.
+//
+// operand is v128 in memory (or constant)
+// lane index is immediate so we're testing something randomish but not zero
+// result is scalar (returned directly)
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "extract_i8x16_9") (result i32)
+      (i8x16.extract_lane_s 9 (v128.load (i32.const 16))))
+    (func (export "const_extract_i8x16_9") (result i32)
+      (i8x16.extract_lane_s 9 (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16)))
+    (func (export "extract_u8x16_6") (result i32)
+      (i8x16.extract_lane_u 6 (v128.load (i32.const 16))))
+    (func (export "const_extract_u8x16_9") (result i32)
+      (i8x16.extract_lane_u 9 (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16)))
+    (func (export "extract_i16x8_5") (result i32)
+      (i16x8.extract_lane_s 5 (v128.load (i32.const 16))))
+    (func (export "const_extract_i16x8_5") (result i32)
+      (i16x8.extract_lane_s 5 (v128.const i16x8 -1 -2 -3 -4 -5 -6 -7 -8)))
+    (func (export "extract_u16x8_3") (result i32)
+      (i16x8.extract_lane_u 3 (v128.load (i32.const 16))))
+    (func (export "const_extract_u16x8_3") (result i32)
+      (i16x8.extract_lane_u 3 (v128.const i16x8 -1 -2 -3 -4 -5 -6 -7 -8)))
+    (func (export "extract_i32x4_2") (result i32)
+      (i32x4.extract_lane 2 (v128.load (i32.const 16))))
+    (func (export "const_extract_i32x4_2") (result i32)
+      (i32x4.extract_lane 2 (v128.const i32x4 -1 -2 -3 -4)))
+    (func (export "extract_i64x2_1") (result i64)
+      (i64x2.extract_lane 1 (v128.load (i32.const 16))))
+    (func (export "const_extract_i64x2_1") (result i64)
+      (i64x2.extract_lane 1 (v128.const i64x2 -1 -2)))
+    (func (export "extract_f32x4_2") (result f32)
+      (f32x4.extract_lane 2 (v128.load (i32.const 16))))
+    (func (export "const_extract_f32x4_2") (result f32)
+      (f32x4.extract_lane 2 (v128.const f32x4 -1 -2 -3 -4)))
+    (func (export "extract_f64x2_1") (result f64)
+      (f64x2.extract_lane 1 (v128.load (i32.const 16))))
+    (func (export "const_extract_f64x2_1") (result f64)
+      (f64x2.extract_lane 1 (v128.const f64x2 -1 -2))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var as = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+var bs = as.map((x) => -x);
+
+set(mem8, 16, as)
+assertEq(ins.exports.extract_i8x16_9(), as[9]);
+
+set(mem8, 16, bs)
+assertEq(ins.exports.extract_u8x16_6(), 256 - as[6]);
+
+assertEq(ins.exports.const_extract_i8x16_9(), -10);
+assertEq(ins.exports.const_extract_u8x16_9(), 256-10);
+
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+var as = [1, 2, 3, 4, 5, 6, 7, 8];
+var bs = as.map((x) => -x);
+
+set(mem16, 8, as)
+assertEq(ins.exports.extract_i16x8_5(), as[5]);
+
+set(mem16, 8, bs)
+assertEq(ins.exports.extract_u16x8_3(), 65536 - as[3]);
+
+assertEq(ins.exports.const_extract_i16x8_5(), -6);
+assertEq(ins.exports.const_extract_u16x8_3(), 65536-4);
+
+var mem32 = new Uint32Array(ins.exports.mem.buffer);
+var as = [1, 2, 3, 4];
+
+set(mem32, 4, as)
+assertEq(ins.exports.extract_i32x4_2(), as[2]);
+
+assertEq(ins.exports.const_extract_i32x4_2(), -3);
+
+var mem32 = new Float32Array(ins.exports.mem.buffer);
+var as = [1.5, 2.5, 3.5, 4.5];
+
+set(mem32, 4, as)
+assertEq(ins.exports.extract_f32x4_2(), as[2]);
+
+assertEq(ins.exports.const_extract_f32x4_2(), -3);
+
+var mem64 = new Float64Array(ins.exports.mem.buffer);
+var as = [1.5, 2.5];
+
+set(mem64, 2, as)
+assertEq(ins.exports.extract_f64x2_1(), as[1]);
+
+assertEq(ins.exports.const_extract_f64x2_1(), -2);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+var as = [12345, 67890];
+
+set(mem64, 2, as)
+assertSame(ins.exports.extract_i64x2_1(), as[1]);
+
+assertEq(ins.exports.const_extract_i64x2_1(), -2n);
+
+// Replace lane
+//
+// operand 1 is v128 in memory
+// operand 2 is immediate scalar
+// lane index is immediate so we're testing something randomish but not zero
+// (note though that fp operations have special cases for zero)
+// result is v128 in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "replace_i8x16_9") (param $value i32)
+      (v128.store (i32.const 0)
+        (i8x16.replace_lane 9 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_i16x8_5") (param $value i32)
+      (v128.store (i32.const 0)
+        (i16x8.replace_lane 5 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_i32x4_3") (param $value i32)
+      (v128.store (i32.const 0)
+        (i32x4.replace_lane 3 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_i64x2_1") (param $value i64)
+      (v128.store (i32.const 0)
+        (i64x2.replace_lane 1 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_f32x4_0") (param $value f32)
+      (v128.store (i32.const 0)
+        (f32x4.replace_lane 0 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_f32x4_3") (param $value f32)
+      (v128.store (i32.const 0)
+        (f32x4.replace_lane 3 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_f64x2_0") (param $value f64)
+      (v128.store (i32.const 0)
+        (f64x2.replace_lane 0 (v128.load (i32.const 16)) (local.get $value))))
+    (func (export "replace_f64x2_1") (param $value f64)
+      (v128.store (i32.const 0)
+        (f64x2.replace_lane 1 (v128.load (i32.const 16)) (local.get $value)))))`);
+
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var as = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+
+set(mem8, 16, as)
+ins.exports.replace_i8x16_9(42);
+assertSame(get(mem8, 0, 16), upd(as, 9, 42));
+
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+var as = [1, 2, 3, 4, 5, 6, 7, 8];
+
+set(mem16, 8, as)
+ins.exports.replace_i16x8_5(42);
+assertSame(get(mem16, 0, 8), upd(as, 5, 42));
+
+var mem32 = new Uint32Array(ins.exports.mem.buffer);
+var as = [1, 2, 3, 4];
+
+set(mem32, 4, as)
+ins.exports.replace_i32x4_3(42);
+assertSame(get(mem32, 0, 4), upd(as, 3, 42));
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+var as = [1, 2];
+
+set(mem64, 2, as)
+ins.exports.replace_i64x2_1(42n);
+assertSame(get(mem64, 0, 2), upd(as, 1, 42));
+
+var mem32 = new Float32Array(ins.exports.mem.buffer);
+var as = [1.5, 2.5, 3.5, 4.5];
+
+set(mem32, 4, as)
+ins.exports.replace_f32x4_0(42.5);
+assertSame(get(mem32, 0, 4), upd(as, 0, 42.5));
+
+set(mem32, 4, as)
+ins.exports.replace_f32x4_3(42.5);
+assertSame(get(mem32, 0, 4), upd(as, 3, 42.5));
+
+var mem64 = new Float64Array(ins.exports.mem.buffer);
+var as = [1.5, 2.5];
+
+set(mem64, 2, as)
+ins.exports.replace_f64x2_0(42.5);
+assertSame(get(mem64, 0, 2), upd(as, 0, 42.5));
+
+set(mem64, 2, as)
+ins.exports.replace_f64x2_1(42.5);
+assertSame(get(mem64, 0, 2), upd(as, 1, 42.5));
+
+// Load and splat
+//
+// Operand is memory address of scalar
+// Result is v128 in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "load_splat_v8x16") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load8_splat (local.get $addr))))
+    (func (export "load_splat_v16x8") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load16_splat (local.get $addr))))
+    (func (export "load_splat_v32x4") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load32_splat (local.get $addr))))
+    (func (export "load_splat_v64x2") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load64_splat (local.get $addr)))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+mem8[37] = 42;
+ins.exports.load_splat_v8x16(37);
+assertSame(get(mem8, 0, 16), [42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42]);
+
+var mem16 = new Uint16Array(ins.exports.mem.buffer);
+mem16[37] = 69;
+ins.exports.load_splat_v16x8(37*2);
+assertSame(get(mem16, 0, 8), [69, 69, 69, 69, 69, 69, 69, 69]);
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+mem32[37] = 83;
+ins.exports.load_splat_v32x4(37*4);
+assertSame(get(mem32, 0, 4), [83, 83, 83, 83]);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+mem64[37] = 83n;
+ins.exports.load_splat_v64x2(37*8);
+assertSame(get(mem64, 0, 2), [83, 83]);
+
+// Load and zero
+//
+// Operand is memory address of scalar
+// Result is v128 in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "load32_zero") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load32_zero (local.get $addr))))
+    (func (export "load64_zero") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load64_zero (local.get $addr)))))`);
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+mem32[37] = 0x12345678;
+mem32[38] = 0xffffffff;
+mem32[39] = 0xfffffffe;
+mem32[40] = 0xfffffffd;
+ins.exports.load32_zero(37*4);
+assertSame(get(mem32, 0, 4), [0x12345678, 0, 0, 0]);
+
+var mem64 = new BigInt64Array(ins.exports.mem.buffer);
+mem64[37] = 0x12345678abcdef01n;
+mem64[38] = 0xffffffffffffffffn;
+ins.exports.load64_zero(37*8);
+assertSame(get(mem64, 0, 2), [0x12345678abcdef01n, 0n]);
+
+// Load and extend
+//
+// Operand is memory address of 64-bit scalar representing 8, 4, or 2 values
+// Result is v128 in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "load8x8_s") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load8x8_s (local.get $addr))))
+    (func (export "load8x8_u") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load8x8_u (local.get $addr))))
+    (func (export "load16x4_s") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load16x4_s (local.get $addr))))
+    (func (export "load16x4_u") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load16x4_u (local.get $addr))))
+    (func (export "load32x2_s") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load32x2_s (local.get $addr))))
+    (func (export "load32x2_u") (param $addr i32)
+      (v128.store (i32.const 0) (v128.load32x2_u (local.get $addr)))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var mem16s = new Int16Array(ins.exports.mem.buffer);
+var mem16u = new Uint16Array(ins.exports.mem.buffer);
+var mem32s = new Int32Array(ins.exports.mem.buffer);
+var mem32u = new Uint32Array(ins.exports.mem.buffer);
+var mem64s = new BigInt64Array(ins.exports.mem.buffer);
+var mem64u = new BigUint64Array(ins.exports.mem.buffer);
+var xs = [42, 129, 2, 212, 44, 27, 12, 199];
+set(mem8, 48, xs);
+
+ins.exports.load8x8_s(48);
+assertSame(get(mem16s, 0, 8), xs.map((x) => sign_extend(x, 8)));
+
+ins.exports.load8x8_u(48);
+assertSame(get(mem16u, 0, 8), xs.map((x) => zero_extend(x, 8)));
+
+var xs = [(42 << 8) | 129, (212 << 8) | 2, (44 << 8) | 27, (199 << 8) | 12];
+set(mem16u, 24, xs);
+
+ins.exports.load16x4_s(48);
+assertSame(get(mem32s, 0, 4), xs.map((x) => sign_extend(x, 16)));
+
+ins.exports.load16x4_u(48);
+assertSame(get(mem32u, 0, 4), xs.map((x) => zero_extend(x, 16)));
+
+var xs = [5, -8];
+set(mem32u, 12, xs);
+
+ins.exports.load32x2_s(48);
+assertSame(get(mem64s, 0, 2), xs.map((x) => sign_extend(x, 32)));
+
+ins.exports.load32x2_u(48);
+assertSame(get(mem64s, 0, 2), xs.map((x) => zero_extend(x, 32)));
+
+// Vector select
+//
+// Operands and results are all in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "bitselect_v128")
+      (v128.store (i32.const 0)
+        (v128.bitselect (v128.load (i32.const 16))
+                        (v128.load (i32.const 32))
+                        (v128.load (i32.const 48))))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+set(mem8, 16, iota(16).map((_) => 0xAA));
+set(mem8, 32, iota(16).map((_) => 0x55));
+
+set(mem8, 48, iota(16).map((_) => 0x99));
+ins.exports.bitselect_v128();
+assertSame(get(mem8, 0, 16), iota(16).map((_) => 0xCC));
+
+set(mem8, 48, iota(16).map((_) => 0x77));
+ins.exports.bitselect_v128();
+assertSame(get(mem8, 0, 16), iota(16).map((_) => 0x22));
+
+// Vector shuffle
+//
+// Operands and results are all in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    ;; the result interleaves the low eight bytes of the inputs
+    (func (export "shuffle1")
+      (v128.store (i32.const 0)
+        (i8x16.shuffle 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23
+           (v128.load (i32.const 16))
+           (v128.load (i32.const 32)))))
+    ;; ditto the high eight bytes
+    (func (export "shuffle2")
+      (v128.store (i32.const 0)
+        (i8x16.shuffle 8 24 9 25 10 26 11 27 12 28 13 29 14 30 15 31
+           (v128.load (i32.const 16))
+           (v128.load (i32.const 32))))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+var xs = iota(16).map((n) => 0xA0 + n);
+var ys = iota(16).map((n) => 0x50 + n);
+set(mem8, 16, xs);
+set(mem8, 32, ys);
+
+ins.exports.shuffle1();
+assertSame(get(mem8, 0, 16), iota(16).map((x) => ((x & 1) ? ys : xs)[x >>> 1]))
+
+ins.exports.shuffle2();
+assertSame(get(mem8, 0, 16), iota(32).map((x) => ((x & 1) ? ys : xs)[x >>> 1]).slice(16));
+
+// Vector swizzle (variable permute).
+//
+// Case 1: Operands and results are all in memory
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "swizzle")
+      (v128.store (i32.const 0)
+        (i8x16.swizzle (v128.load (i32.const 16)) (v128.load (i32.const 32))))))`);
+
+var mem8 = new Uint8Array(ins.exports.mem.buffer);
+
+var xs = [100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115];
+set(mem8, 16, xs);
+
+set(mem8, 32, [1,0,3,2,5,4,7,6,9,8,11,10,13,12,15,14]);
+ins.exports.swizzle();
+assertSame(get(mem8, 0, 16), [101,100,103,102,105,104,107,106,109,108,111,110,113,112,115,114]);
+
+set(mem8, 32, [9,8,11,10,13,12,16,14,1,0,3,2,5,192,7,6]);
+ins.exports.swizzle();
+assertSame(get(mem8, 0, 16), [109,108,111,110,113,112,0,114,101,100,103,102,105,0,107,106]);
+
+// Case 2: The mask operand is a constant; the swizzle gets optimized into a
+// shuffle (also see ion-analysis.js).
+
+for ( let [mask, expected] of [[[1,0,3,2,5,4,7,6,9,8,11,10,13,12,15,14],
+                                [101,100,103,102,105,104,107,106,109,108,111,110,113,112,115,114]],
+                               [[9,8,11,10,13,12,16,14,1,0,3,2,5,192,7,6],
+                                [109,108,111,110,113,112,0,114,101,100,103,102,105,0,107,106]]] ) {
+
+    let ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "swizzle")
+      (v128.store (i32.const 0)
+        (i8x16.swizzle (v128.load (i32.const 16)) (v128.const i8x16 ${mask.join(' ')})))))
+`);
+
+    let mem8 = new Uint8Array(ins.exports.mem.buffer);
+    set(mem8, 16, [100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115]);
+    ins.exports.swizzle();
+    assertSame(get(mem8, 0, 16), expected);
+}
+
+// Convert integer to floating point
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "convert_s")
+      (v128.store (i32.const 0)
+        (f32x4.convert_i32x4_s (v128.load (i32.const 16)))))
+    (func (export "convert_u")
+      (v128.store (i32.const 0)
+        (f32x4.convert_i32x4_u (v128.load (i32.const 16))))))`);
+
+var mem32s = new Int32Array(ins.exports.mem.buffer);
+var mem32f = new Float32Array(ins.exports.mem.buffer);
+var xs = [1, -9, 77987, -34512];
+
+set(mem32s, 4, xs);
+ins.exports.convert_s();
+assertSame(get(mem32f, 0, 4), xs);
+
+var mem32u = new Uint32Array(ins.exports.mem.buffer);
+var ys = xs.map((x) => x>>>0);
+
+set(mem32u, 4, ys);
+ins.exports.convert_u();
+assertSame(get(mem32f, 0, 4), ys.map(Math.fround));
+
+// Convert floating point to integer with saturating truncation
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "trunc_sat_s")
+      (v128.store (i32.const 0)
+        (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 16)))))
+    (func (export "trunc_sat_u")
+      (v128.store (i32.const 0)
+        (i32x4.trunc_sat_f32x4_u (v128.load (i32.const 16))))))`);
+
+var mem32s = new Int32Array(ins.exports.mem.buffer);
+var mem32u = new Uint32Array(ins.exports.mem.buffer);
+var mem32f = new Float32Array(ins.exports.mem.buffer);
+var xs = [1.5, -9.5, 7.5e12, -8e13];
+
+set(mem32f, 4, xs);
+ins.exports.trunc_sat_s();
+assertSame(get(mem32s, 0, 4), [1, -9, 0x7FFFFFFF, -0x80000000]);
+
+var xs = [1.5, -9.5, 7.5e12, 812];
+set(mem32f, 4, xs);
+ins.exports.trunc_sat_u();
+assertSame(get(mem32u, 0, 4), [1, 0, 0xFFFFFFFF, 812]);
+
+var xs = [0, -0, 0x80860000, 0x100000000];
+set(mem32f, 4, xs);
+ins.exports.trunc_sat_u();
+assertSame(get(mem32u, 0, 4), [0, 0, 0x80860000, 0xFFFFFFFF]);
+
+// Loops and blocks.  This should at least test "sync" in the baseline compiler.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $f (param $count i32) (param $v v128) (result v128)
+      (local $tmp v128)
+      (block $B1
+        (loop $L1
+          (br_if $B1 (i32.eqz (local.get $count)))
+          (local.set $tmp (i32x4.add (local.get $tmp) (local.get $v)))
+          (local.set $count (i32.sub (local.get $count) (i32.const 1)))
+          (br $L1)))
+      (local.get $tmp))
+    (func (export "run") (param $count i32)
+      (v128.store (i32.const 0)
+        (call $f (local.get $count) (v128.load (i32.const 16))))))`);
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+set(mem32, 4, [1,2,3,4]);
+ins.exports.run(7);
+assertSame(get(mem32, 0, 4), [7,14,21,28]);
+
+// Lots of parameters, this should trigger stack parameter passing
+//
+// 10 parameters in memory, we load them and pass them and operate on them.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $f (param $v0 v128) (param $v1 v128) (param $v2 v128) (param $v3 v128) (param $v4 v128)
+             (param $v5 v128) (param $v6 v128) (param $v7 v128) (param $v8 v128) (param $v9 v128)
+             (result v128)
+      (i32x4.add (local.get $v0)
+        (i32x4.add (local.get $v1)
+          (i32x4.add (local.get $v2)
+            (i32x4.add (local.get $v3)
+              (i32x4.add (local.get $v4)
+                (i32x4.add (local.get $v5)
+                  (i32x4.add (local.get $v6)
+                    (i32x4.add (local.get $v7)
+                      (i32x4.add (local.get $v8) (local.get $v9)))))))))))
+    (func (export "run")
+      (v128.store (i32.const 0)
+        (call $f (v128.load (i32.const ${16*1}))
+                 (v128.load (i32.const ${16*2}))
+                 (v128.load (i32.const ${16*3}))
+                 (v128.load (i32.const ${16*4}))
+                 (v128.load (i32.const ${16*5}))
+                 (v128.load (i32.const ${16*6}))
+                 (v128.load (i32.const ${16*7}))
+                 (v128.load (i32.const ${16*8}))
+                 (v128.load (i32.const ${16*9}))
+                 (v128.load (i32.const ${16*10}))))))`);
+
+
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var sum = [0, 0, 0, 0];
+for ( let i=1; i <= 10; i++ ) {
+    let v = [1,2,3,4].map((x) => x*i);
+    set(mem32, 4*i, v);
+    for ( let j=0; j < 4; j++ )
+        sum[j] += v[j];
+}
+
+ins.exports.run();
+
+assertSame(get(mem32, 0, 4), sum);
+
+// Globals.
+//
+// We have a number of different code paths and representations and
+// need to test them all.
+//
+// Cases:
+//  - private global, mutable / immutable, initialized from constant or imported immutable global
+//  - exported global, mutable / immutable, initialized from constant or imported immutable global
+//  - imported global, mutable / immutable
+//  - imported global that's re-exported, mutable / immutable
+
+// Global used for initialization below.
+
+var init = (function () {
+    var ins = wasmEvalText(`
+      (module
+        (global (export "init") v128 (v128.const i32x4 9 8 7 6)))`);
+    return ins.exports;
+})();
+
+for ( let exportspec of ['', '(export "g")'] ) {
+
+    // Private/exported immutable initialized from constant
+
+    let ins1 = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (global $g ${exportspec} v128 (v128.const i32x4 9 8 7 6))
+    (func (export "get") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`);
+
+    let mem1 = new Int32Array(ins1.exports.mem.buffer);
+    ins1.exports.get(0);
+    assertSame(get(mem1, 0, 4), [9, 8, 7, 6]);
+
+    // Private/exported mutable initialized from constant
+
+    let ins2 = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (global $g ${exportspec} (mut v128) (v128.const i32x4 9 8 7 6))
+    (func (export "put") (param $val i32)
+      (global.set $g (i32x4.splat (local.get $val))))
+    (func (export "get") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`);
+
+    let mem2 = new Int32Array(ins2.exports.mem.buffer);
+    ins2.exports.get(0);
+    assertSame(get(mem2, 0, 4), [9, 8, 7, 6]);
+    ins2.exports.put(37);
+    ins2.exports.get(0);
+    assertSame(get(mem2, 0, 4), [37, 37, 37, 37]);
+
+    // Private/exported immutable initialized from imported immutable global
+
+    let ins3 = wasmEvalText(`
+  (module
+    (global $init (import "m" "init") v128)
+    (memory (export "mem") 1 1)
+    (global $g ${exportspec} v128 (global.get $init))
+    (func (export "get") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`,
+                       {m:init});
+
+    let mem3 = new Int32Array(ins3.exports.mem.buffer);
+    ins3.exports.get(0);
+    assertSame(get(mem3, 0, 4), [9, 8, 7, 6]);
+
+    // Private/exported mutable initialized from imported immutable global
+
+    let ins4 = wasmEvalText(`
+  (module
+    (global $init (import "m" "init") v128)
+    (memory (export "mem") 1 1)
+    (global $g ${exportspec} (mut v128) (global.get $init))
+    (func (export "put") (param $val i32)
+      (global.set $g (i32x4.splat (local.get $val))))
+    (func (export "get") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`,
+                       {m:init});
+
+    let mem4 = new Int32Array(ins4.exports.mem.buffer);
+    ins4.exports.get(0);
+    assertSame(get(mem4, 0, 4), [9, 8, 7, 6]);
+    ins4.exports.put(37);
+    ins4.exports.get(0);
+    assertSame(get(mem4, 0, 4), [37, 37, 37, 37]);
+
+    // Imported private/re-exported immutable
+
+    let ins5 = wasmEvalText(`
+  (module
+    (global $g ${exportspec} (import "m" "init") v128)
+    (memory (export "mem") 1 1)
+    (func (export "get") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`,
+                       {m:init});
+
+    let mem5 = new Int32Array(ins5.exports.mem.buffer);
+    ins5.exports.get(0);
+    assertSame(get(mem5, 0, 4), [9, 8, 7, 6]);
+
+    // Imported private/re-exported mutable
+
+    let mutg = (function () {
+        var ins = wasmEvalText(`
+      (module
+        (global (export "mutg") (mut v128) (v128.const i32x4 19 18 17 16)))`);
+        return ins.exports;
+    })();
+
+    let ins6 = wasmEvalText(`
+  (module
+    (global $g ${exportspec} (import "m" "mutg") (mut v128))
+    (memory (export "mem") 1 1)
+    (func (export "put") (param $val i32)
+      (global.set $g (i32x4.splat (local.get $val))))
+    (func (export "get") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`,
+                       {m:mutg});
+
+    let mem6 = new Int32Array(ins6.exports.mem.buffer);
+    ins6.exports.get(0);
+    assertSame(get(mem6, 0, 4), [19, 18, 17, 16]);
+    ins6.exports.put(37);
+    ins6.exports.get(0);
+    assertSame(get(mem6, 0, 4), [37, 37, 37, 37]);
+}
+
+// Imports and exports that pass and return v128
+
+var insworker = wasmEvalText(`
+  (module
+    (func (export "worker") (param v128) (result v128)
+      (i8x16.add (local.get 0) (v128.const i8x16 ${iota(16).join(' ')}))))`);
+
+var insrun = wasmEvalText(`
+  (module
+    (import "" "worker" (func $worker (param v128) (result v128)))
+    (memory (export "mem") 1 1)
+    (func (export "run") (param $srcloc i32) (param $destloc i32)
+      (v128.store (local.get $destloc)
+        (call $worker (v128.load (local.get $srcloc))))))`,
+                          {"":insworker.exports});
+
+var mem = new Uint8Array(insrun.exports.mem.buffer);
+var xs = iota(16).map((x) => x+5);
+set(mem, 0, xs);
+insrun.exports.run(0, 16);
+assertSame(get(mem, 16, 16), xs.map((x,i) => x+i))
+
+// Make sure JS<->wasm call guards are sensible.
+
+// Calling from JS to export that accepts v128.
+assertErrorMessage(() => insworker.exports.worker(),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+// Calling from wasm with v128 to import that comes from JS.  The instantiation
+// will succeed even if the param type of the import is v128 (see "create a host
+// function" in the Wasm JSAPI spec), it is the act of invoking it that checks
+// that verboten types are not used (see "run a host function", ibid.).
+var badImporter = wasmEvalText(`
+  (module
+    (import "" "worker" (func $worker (param v128) (result v128)))
+    (func (export "run")
+      (drop (call $worker (v128.const i32x4 0 1 2 3)))))`,
+             {"":{worker: function(a) { return a; }}});
+
+assertErrorMessage(() => badImporter.exports.run(),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+// Imports and exports that pass and return v128 as stack (not register) args.
+
+var exportWithStackArgs = wasmEvalText(`
+  (module
+    (func (export "worker") (param v128) (param v128) (param v128) (param v128)
+                            (param v128) (param v128) (param v128) (param v128)
+                            (param v128) (param v128) (param v128) (param v128)
+                            (param v128) (param v128)
+           (result v128 v128)
+      (i8x16.add (local.get 3) (local.get 12))
+      (local.get 7)))`);
+
+var importWithStackArgs = wasmEvalText(`
+  (module
+    (type $t1 (func (param v128) (param v128) (param v128) (param v128)
+                    (param v128) (param v128) (param v128) (param v128)
+                    (param v128) (param v128) (param v128) (param v128)
+                    (param v128) (param v128)
+                    (result v128 v128)))
+    (import "" "worker" (func $worker (type $t1)))
+    (memory (export "mem") 1 1)
+    (table funcref (elem $worker))
+    (func (export "run")
+      (i32.const 16)
+      (call_indirect (type $t1) (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) (v128.const i32x4 5 5 5 5) (v128.const i32x4 6 6 6 6)
+                    (v128.const i32x4 7 7 7 7) (v128.const i32x4 8 8 8 8) (v128.const i32x4 9 9 9 9)
+                    (v128.const i32x4 10 10 10 10) (v128.const i32x4 11 11 11 11) (v128.const i32x4 12 12 12 12)
+                    (v128.const i32x4 13 13 13 13) (v128.const i32x4 14 14 14 14)
+           (i32.const 0))
+      drop
+      v128.store
+      (i32.const 0)
+      (call $worker (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) (v128.const i32x4 5 5 5 5) (v128.const i32x4 6 6 6 6)
+                    (v128.const i32x4 7 7 7 7) (v128.const i32x4 8 8 8 8) (v128.const i32x4 9 9 9 9)
+                    (v128.const i32x4 10 10 10 10) (v128.const i32x4 11 11 11 11) (v128.const i32x4 12 12 12 12)
+                    (v128.const i32x4 13 13 13 13) (v128.const i32x4 14 14 14 14))
+      drop
+      v128.store))`,
+                                       {"": exportWithStackArgs.exports});
+
+var mem = new Int32Array(importWithStackArgs.exports.mem.buffer);
+importWithStackArgs.exports.run();
+assertSame(get(mem, 0, 4), [17, 17, 17, 17]);
+assertSame(get(mem, 4, 4), [17, 17, 17, 17]);
+
+// Imports and exports of v128 globals
+
+var insexporter = wasmEvalText(`
+  (module
+    (global (export "myglobal") (mut v128) (v128.const i8x16 ${iota(16).join(' ')})))`);
+
+var insimporter = wasmEvalText(`
+  (module
+    (import "m" "myglobal" (global $g (mut v128)))
+    (memory (export "mem") 1 1)
+    (func (export "run") (param $dest i32)
+      (v128.store (local.get $dest) (global.get $g))))`,
+                               {m:insexporter.exports});
+
+var mem = new Uint8Array(insimporter.exports.mem.buffer);
+insimporter.exports.run(16);
+assertSame(get(mem, 16, 16), iota(16));
+
+// Guards on accessing v128 globals from JS
+
+assertErrorMessage(() => insexporter.exports.myglobal.value = 0,
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+assertErrorMessage(function () { let v = insexporter.exports.myglobal.value },
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+// Multi-value cases + v128 parameters to if, block, loop
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func $mvreturn (result v128 v128 v128)
+      (v128.load (i32.const 16))
+      (v128.load (i32.const 0))
+      (v128.load (i32.const 32)))
+    (func (export "runreturn")
+      i32.const 48
+      (call $mvreturn)
+      i32x4.sub ;; [-20, -20, -20, -20]
+      i32x4.sub ;; [31, 32, 33, 34]
+      v128.store)
+    (func (export "runif") (param $cond i32)
+      i32.const 48
+      (v128.load (i32.const 0))
+      (v128.load (i32.const 16))
+      (if (param v128) (param v128) (result v128 v128)
+          (local.get $cond)
+          (then i32x4.add
+                (v128.load (i32.const 32)))
+          (else i32x4.sub
+                (v128.load (i32.const 0))))
+      i32x4.add
+      v128.store)
+    (func (export "runblock")
+      i32.const 48
+      (v128.load (i32.const 0))
+      (v128.load (i32.const 16))
+      (block (param v128 v128) (result v128 v128)
+          i32x4.add
+          (v128.load (i32.const 32)))
+      i32x4.add
+      v128.store)
+    (func (export "runloop") (param $count i32)
+      i32.const 48
+      (v128.load (i32.const 0))
+      (v128.load (i32.const 16))
+      (block $B (param v128 v128) (result v128 v128)
+        (loop $L (param v128 v128) (result v128 v128)
+          i32x4.add
+          (v128.load (i32.const 32))
+          (local.set $count (i32.sub (local.get $count) (i32.const 1)))
+          (br_if $B (i32.eqz (local.get $count)))
+          (br $L)))
+      i32x4.add
+      v128.store))`);
+
+var mem = new Int32Array(ins.exports.mem.buffer);
+set(mem, 0, [1, 2, 3, 4]);
+set(mem, 4, [11, 12, 13, 14]);
+set(mem, 8, [21, 22, 23, 24]);
+
+// Multi-value returns
+
+ins.exports.runreturn();
+assertSame(get(mem, 12, 4), [31, 32, 33, 34]);
+
+// Multi-parameters to and multi-returns from "if"
+
+// This should be vector@0 + vector@16 + vector@32
+ins.exports.runif(1);
+assertSame(get(mem, 12, 4),
+           [33, 36, 39, 42]);
+
+// This should be vector@0 - vector@16 + vector@0
+ins.exports.runif(0);
+assertSame(get(mem, 12, 4),
+           [-9, -8, -7, -6]);
+
+// This should be vector@0 + vector@16 + vector@32
+ins.exports.runblock();
+assertSame(get(mem, 12, 4),
+           [33, 36, 39, 42]);
+
+// This should be vector@0 + vector@16 + N * vector@32 where
+// N is the parameter to runloop.
+ins.exports.runloop(3);
+assertSame(get(mem, 12, 4),
+           [12+3*21, 14+3*22, 16+3*23, 18+3*24]);
diff --git a/js/src/jit-test/tests/wasm/simd/avx2-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/avx2-x64-ion-codegen.js
new file mode 100644
index 0000000000..af8269e190
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/avx2-x64-ion-codegen.js
@@ -0,0 +1,584 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || !isAvxPresent(); include:codegen-x64-test.js
+
+// Test that there are no extraneous moves for various SIMD conversion
+// operations. See README-codegen.md for general information about this type of
+// test case.
+
+// Note, these tests test the beginning of the output but not the end.
+
+// Currently AVX2 exhibits a defect when function uses its first v128 arg and
+// returns v128: the register allocator adds unneeded extra moves from xmm0,
+// then into different temporary, and then the latter temporary is used as arg.
+// In the tests below, to simplify things, don't use/ignore the first arg.
+// v128 OP v128 -> v128
+// inputs: [[complete-opname, expected-pattern], ...]
+function codegenTestX64_v128xv128_v128_avxhack(inputs, options = {}) {
+     for ( let [op, expected] of inputs ) {
+         codegenTestX64_adhoc(wrap(options, `
+         (func (export "f") (param v128 v128 v128) (result v128)
+           (${op} (local.get 1) (local.get 2)))`),
+                              'f',
+                              expected,
+                              options);
+     }
+}
+// (see codegenTestX64_v128xv128_v128_avxhack comment about AVX defect)
+// v128 OP const -> v128
+// inputs: [[complete-opname, const, expected-pattern], ...]
+function codegenTestX64_v128xLITERAL_v128_avxhack(inputs, options = {}) {
+     for ( let [op, const_, expected] of inputs ) {
+         codegenTestX64_adhoc(wrap(options, `
+         (func (export "f") (param v128 v128) (result v128)
+           (${op} (local.get 1) ${const_}))`),
+                              'f',
+                              expected,
+                              options);
+     }
+}
+// (see codegenTestX64_v128xv128_v128_avxhack comment about AVX defect)
+// const OP v128 -> v128
+// inputs: [[complete-opname, const, expected-pattern], ...]
+function codegenTestX64_LITERALxv128_v128_avxhack(inputs, options = {}) {
+     for ( let [op, const_, expected] of inputs ) {
+         codegenTestX64_adhoc(wrap(options, `
+         (func (export "f") (param v128 v128) (result v128)
+           (${op} ${const_} (local.get 1)))`),
+                              'f',
+                              expected,
+                              options);
+     }
+}
+
+// Utility function to test SIMD operations encoding, where the input argument
+// has the specified type (T).
+// inputs: [[type, complete-opname, expected-pattern], ...]
+function codegenTestX64_T_v128_avxhack(inputs, options = {}) {
+     for ( let [ty, op, expected] of inputs ) {
+         codegenTestX64_adhoc(wrap(options, `
+         (func (export "f") (param ${ty}) (result v128)
+           (${op} (local.get 0)))`),
+                              'f',
+                              expected,
+                              options);
+     }
+}
+
+// Machers for any 64- and 32-bit registers.
+var GPR_I64 = "%r\\w+";
+var GPR_I32 = "%(?:e\\w+|r\\d+d)";
+
+// Simple binary ops: e.g. add, sub, mul
+codegenTestX64_v128xv128_v128_avxhack(
+     [['i8x16.avgr_u',    `c5 f1 e0 c2               vpavgb %xmm2, %xmm1, %xmm0`],
+      ['i16x8.avgr_u',    `c5 f1 e3 c2               vpavgw %xmm2, %xmm1, %xmm0`],
+      ['i8x16.add',       `c5 f1 fc c2               vpaddb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.add_sat_s', `c5 f1 ec c2               vpaddsb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.add_sat_u', `c5 f1 dc c2               vpaddusb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.sub',       `c5 f1 f8 c2               vpsubb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.sub_sat_s', `c5 f1 e8 c2               vpsubsb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.sub_sat_u', `c5 f1 d8 c2               vpsubusb %xmm2, %xmm1, %xmm0`],
+      ['i16x8.mul',       `c5 f1 d5 c2               vpmullw %xmm2, %xmm1, %xmm0`],
+      ['i16x8.min_s',     `c5 f1 ea c2               vpminsw %xmm2, %xmm1, %xmm0`],
+      ['i16x8.min_u',     `c4 e2 71 3a c2            vpminuw %xmm2, %xmm1, %xmm0`],
+      ['i16x8.max_s',     `c5 f1 ee c2               vpmaxsw %xmm2, %xmm1, %xmm0`],
+      ['i16x8.max_u',     `c4 e2 71 3e c2            vpmaxuw %xmm2, %xmm1, %xmm0`],
+      ['i32x4.add',       `c5 f1 fe c2               vpaddd %xmm2, %xmm1, %xmm0`],
+      ['i32x4.sub',       `c5 f1 fa c2               vpsubd %xmm2, %xmm1, %xmm0`],
+      ['i32x4.mul',       `c4 e2 71 40 c2            vpmulld %xmm2, %xmm1, %xmm0`],
+      ['i32x4.min_s',     `c4 e2 71 39 c2            vpminsd %xmm2, %xmm1, %xmm0`],
+      ['i32x4.min_u',     `c4 e2 71 3b c2            vpminud %xmm2, %xmm1, %xmm0`],
+      ['i32x4.max_s',     `c4 e2 71 3d c2            vpmaxsd %xmm2, %xmm1, %xmm0`],
+      ['i32x4.max_u',     `c4 e2 71 3f c2            vpmaxud %xmm2, %xmm1, %xmm0`],
+      ['i64x2.add',       `c5 f1 d4 c2               vpaddq %xmm2, %xmm1, %xmm0`],
+      ['i64x2.sub',       `c5 f1 fb c2               vpsubq %xmm2, %xmm1, %xmm0`],
+      ['i64x2.mul', `
+c5 e1 73 d1 20            vpsrlq \\$0x20, %xmm1, %xmm3
+66 0f f4 da               pmuludq %xmm2, %xmm3
+c5 81 73 d2 20            vpsrlq \\$0x20, %xmm2, %xmm15
+66 44 0f f4 f9            pmuludq %xmm1, %xmm15
+66 44 0f d4 fb            paddq %xmm3, %xmm15
+66 41 0f 73 f7 20         psllq \\$0x20, %xmm15
+c5 f1 f4 c2               vpmuludq %xmm2, %xmm1, %xmm0
+66 41 0f d4 c7            paddq %xmm15, %xmm0`],
+      ['f32x4.add',            `c5 f0 58 c2               vaddps %xmm2, %xmm1, %xmm0`],
+      ['f32x4.sub',            `c5 f0 5c c2               vsubps %xmm2, %xmm1, %xmm0`],
+      ['f32x4.mul',            `c5 f0 59 c2               vmulps %xmm2, %xmm1, %xmm0`],
+      ['f32x4.div',            `c5 f0 5e c2               vdivps %xmm2, %xmm1, %xmm0`],
+      ['f64x2.add',            `c5 f1 58 c2               vaddpd %xmm2, %xmm1, %xmm0`],
+      ['f64x2.sub',            `c5 f1 5c c2               vsubpd %xmm2, %xmm1, %xmm0`],
+      ['f64x2.mul',            `c5 f1 59 c2               vmulpd %xmm2, %xmm1, %xmm0`],
+      ['f64x2.div',            `c5 f1 5e c2               vdivpd %xmm2, %xmm1, %xmm0`],
+      ['i8x16.narrow_i16x8_s', `c5 f1 63 c2               vpacksswb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.narrow_i16x8_u', `c5 f1 67 c2               vpackuswb %xmm2, %xmm1, %xmm0`],
+      ['i16x8.narrow_i32x4_s', `c5 f1 6b c2               vpackssdw %xmm2, %xmm1, %xmm0`],
+      ['i16x8.narrow_i32x4_u', `c4 e2 71 2b c2            vpackusdw %xmm2, %xmm1, %xmm0`],
+      ['i32x4.dot_i16x8_s',    `c5 f1 f5 c2               vpmaddwd %xmm2, %xmm1, %xmm0`]]);
+
+// Simple comparison ops
+codegenTestX64_v128xv128_v128_avxhack(
+     [['i8x16.eq', `c5 f1 74 c2               vpcmpeqb %xmm2, %xmm1, %xmm0`],
+      ['i8x16.ne', `
+c5 f1 74 c2               vpcmpeqb %xmm2, %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i8x16.lt_s', `c5 e9 64 c1               vpcmpgtb %xmm1, %xmm2, %xmm0`],
+      ['i8x16.gt_u', `
+c5 f1 de c2               vpmaxub %xmm2, %xmm1, %xmm0
+66 0f 74 c2               pcmpeqb %xmm2, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i16x8.eq', `c5 f1 75 c2               vpcmpeqw %xmm2, %xmm1, %xmm0`],
+      ['i16x8.ne', `
+c5 f1 75 c2               vpcmpeqw %xmm2, %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i16x8.le_s', `
+c5 f1 65 c2               vpcmpgtw %xmm2, %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i16x8.ge_u', `
+c4 e2 71 3a c2            vpminuw %xmm2, %xmm1, %xmm0
+66 0f 75 c2               pcmpeqw %xmm2, %xmm0`],
+      ['i32x4.eq', `c5 f1 76 c2               vpcmpeqd %xmm2, %xmm1, %xmm0`],
+      ['i32x4.ne', `
+c5 f1 76 c2               vpcmpeqd %xmm2, %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i32x4.lt_s', `c5 e9 66 c1               vpcmpgtd %xmm1, %xmm2, %xmm0`],
+      ['i32x4.gt_u', `
+c4 e2 71 3f c2            vpmaxud %xmm2, %xmm1, %xmm0
+66 0f 76 c2               pcmpeqd %xmm2, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i64x2.eq', `c4 e2 71 29 c2            vpcmpeqq %xmm2, %xmm1, %xmm0`],
+      ['i64x2.ne', `
+c4 e2 71 29 c2            vpcmpeqq %xmm2, %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i64x2.lt_s', `c4 e2 69 37 c1            vpcmpgtq %xmm1, %xmm2, %xmm0`],
+      ['i64x2.ge_s', `
+c4 e2 69 37 c1            vpcmpgtq %xmm1, %xmm2, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['f32x4.eq', `c5 f0 c2 c2 00            vcmpps \\$0x00, %xmm2, %xmm1, %xmm0`],
+      ['f32x4.lt', `c5 f0 c2 c2 01            vcmpps \\$0x01, %xmm2, %xmm1, %xmm0`],
+      ['f32x4.ge', `c5 e8 c2 c1 02            vcmpps \\$0x02, %xmm1, %xmm2, %xmm0`],
+      ['f64x2.eq', `c5 f1 c2 c2 00            vcmppd \\$0x00, %xmm2, %xmm1, %xmm0`],
+      ['f64x2.lt', `c5 f1 c2 c2 01            vcmppd \\$0x01, %xmm2, %xmm1, %xmm0`],
+      ['f64x2.ge', `c5 e9 c2 c1 02            vcmppd \\$0x02, %xmm1, %xmm2, %xmm0`],
+      ['f32x4.pmin', `c5 e8 5d c1               vminps %xmm1, %xmm2, %xmm0`],
+      ['f32x4.pmax', `c5 e8 5f c1               vmaxps %xmm1, %xmm2, %xmm0`],
+      ['f64x2.pmin', `c5 e9 5d c1               vminpd %xmm1, %xmm2, %xmm0`],
+      ['f64x2.pmax', `c5 e9 5f c1               vmaxpd %xmm1, %xmm2, %xmm0`],
+      ['i8x16.swizzle', `
+c5 69 dc 3d ${RIPRADDR}   vpaddusbx ${RIPR}, %xmm2, %xmm15
+c4 c2 71 00 c7            vpshufb %xmm15, %xmm1, %xmm0`],
+      ['i16x8.extmul_high_i8x16_s', `
+66 44 0f 3a 0f fa 08      palignr \\$0x08, %xmm2, %xmm15
+c4 42 79 20 ff            vpmovsxbw %xmm15, %xmm15
+66 0f 3a 0f c1 08         palignr \\$0x08, %xmm1, %xmm0
+c4 e2 79 20 c0            vpmovsxbw %xmm0, %xmm0
+66 41 0f d5 c7            pmullw %xmm15, %xmm0`],
+      ['i32x4.extmul_low_i16x8_u', `
+c5 71 e4 fa               vpmulhuw %xmm2, %xmm1, %xmm15
+c5 f1 d5 c2               vpmullw %xmm2, %xmm1, %xmm0
+66 41 0f 61 c7            punpcklwd %xmm15, %xmm0`],
+      ['i64x2.extmul_low_i32x4_s', `
+c5 79 70 f9 10            vpshufd \\$0x10, %xmm1, %xmm15
+c5 f9 70 c2 10            vpshufd \\$0x10, %xmm2, %xmm0
+66 41 0f 38 28 c7         pmuldq %xmm15, %xmm0`],
+      ['i16x8.q15mulr_sat_s', `
+c4 e2 71 0b c2            vpmulhrsw %xmm2, %xmm1, %xmm0
+c5 79 75 3d ${RIPRADDR}   vpcmpeqwx ${RIPR}, %xmm0, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+]);
+
+// Bitwise binary ops
+codegenTestX64_v128xv128_v128_avxhack(
+     [['v128.and', `c5 f1 db c2               vpand %xmm2, %xmm1, %xmm0`],
+      ['v128.andnot', `c5 e9 df c1               vpandn %xmm1, %xmm2, %xmm0`],
+      ['v128.or', `c5 f1 eb c2               vpor %xmm2, %xmm1, %xmm0`],
+      ['v128.xor', `c5 f1 ef c2               vpxor %xmm2, %xmm1, %xmm0`]]);
+
+
+// Replace lane ops.
+codegenTestX64_adhoc(`(module
+     (func (export "f") (param v128 v128 i32) (result v128)
+          (i8x16.replace_lane 7 (local.get 1) (local.get 2))))`, 'f', `
+c4 .. 71 20 .. 07         vpinsrb \\$0x07, ${GPR_I32}, %xmm1, %xmm0`);
+codegenTestX64_adhoc(`(module
+     (func (export "f") (param v128 v128 i32) (result v128)
+          (i16x8.replace_lane 3 (local.get 1) (local.get 2))))`, 'f', `
+(?:c4 .. 71|c5 f1) c4 .. 03            vpinsrw \\$0x03, ${GPR_I32}, %xmm1, %xmm0`);
+codegenTestX64_adhoc(`(module
+     (func (export "f") (param v128 v128 i32) (result v128)
+          (i32x4.replace_lane 2 (local.get 1) (local.get 2))))`, 'f', `
+c4 .. 71 22 .. 02         vpinsrd \\$0x02, ${GPR_I32}, %xmm1, %xmm0`);
+codegenTestX64_adhoc(`(module
+     (func (export "f") (param v128 v128 i64) (result v128)
+          (i64x2.replace_lane 1 (local.get 1) (local.get 2))))`, 'f', `
+c4 .. f1 22 .. 01         vpinsrq \\$0x01, ${GPR_I64}, %xmm1, %xmm0`);
+     
+                             
+if (isAvxPresent(2)) {
+     codegenTestX64_T_v128_avxhack(
+          [['i32', 'i8x16.splat', `
+c5 f9 6e ..               vmovd ${GPR_I32}, %xmm0
+c4 e2 79 78 c0            vpbroadcastb %xmm0, %xmm0`],
+           ['i32', 'i16x8.splat', `
+c5 f9 6e ..               vmovd ${GPR_I32}, %xmm0
+c4 e2 79 79 c0            vpbroadcastw %xmm0, %xmm0`],
+           ['i32', 'i32x4.splat', `
+c5 f9 6e ..               vmovd ${GPR_I32}, %xmm0
+c4 e2 79 58 c0            vpbroadcastd %xmm0, %xmm0`],
+           ['i64', 'i64x2.splat', `
+c4 e1 f9 6e ..            vmovq ${GPR_I64}, %xmm0
+c4 e2 79 59 c0            vpbroadcastq %xmm0, %xmm0`],
+           ['f32', 'f32x4.splat', `c4 e2 79 18 c0            vbroadcastss %xmm0, %xmm0`]], {log:true});
+
+     codegenTestX64_T_v128_avxhack(
+          [['i32', 'v128.load8_splat',
+            'c4 c2 79 78 04 ..         vpbroadcastbb \\(%r15,%r\\w+,1\\), %xmm0'],
+           ['i32', 'v128.load16_splat',
+            'c4 c2 79 79 04 ..         vpbroadcastww \\(%r15,%r\\w+,1\\), %xmm0'],
+           ['i32', 'v128.load32_splat',
+            'c4 c2 79 18 04 ..         vbroadcastssl \\(%r15,%r\\w+,1\\), %xmm0']], {memory: 1});
+}
+
+// Using VEX during shuffle ops
+codegenTestX64_v128xv128_v128_avxhack([
+     // Identity op on second argument should generate a move
+    ['i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15',
+     'c5 f9 6f c1               vmovdqa %xmm1, %xmm0'],
+
+     // Broadcast a byte from first argument
+    ['i8x16.shuffle 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5',
+     `
+c5 f1 60 c1               vpunpcklbw %xmm1, %xmm1, %xmm0
+c5 fa 70 c0 55            vpshufhw \\$0x55, %xmm0, %xmm0
+c5 f9 70 c0 aa            vpshufd \\$0xAA, %xmm0, %xmm0`],
+
+     // Broadcast a word from first argument
+    ['i8x16.shuffle 4 5 4 5 4 5 4 5 4 5 4 5 4 5 4 5',
+     `
+c5 fb 70 c1 aa            vpshuflw \\$0xAA, %xmm1, %xmm0
+c5 f9 70 c0 00            vpshufd \\$0x00, %xmm0, %xmm0`],
+
+     // Permute words
+     ['i8x16.shuffle 2 3 0 1 6 7 4 5 10 11 8 9 14 15 12 13',
+`
+c5 fb 70 c1 b1            vpshuflw \\$0xB1, %xmm1, %xmm0
+c5 fa 70 c0 b1            vpshufhw \\$0xB1, %xmm0, %xmm0`],
+
+     // Permute doublewords
+     ['i8x16.shuffle 4 5 6 7 0 1 2 3 12 13 14 15 8 9 10 11',
+      'c5 f9 70 c1 b1            vpshufd \\$0xB1, %xmm1, %xmm0'],
+
+     // Interleave doublewords
+     ['i8x16.shuffle 0 1 2 3 16 17 18 19 4 5 6 7 20 21 22 23',
+      'c5 f1 62 c2               vpunpckldq %xmm2, %xmm1, %xmm0'],
+
+     // Interleave quadwords
+     ['i8x16.shuffle 24 25 26 27 28 29 30 31 8 9 10 11 12 13 14 15',
+      'c5 e9 6d c1               vpunpckhqdq %xmm1, %xmm2, %xmm0'],
+     
+     // Rotate right
+    ['i8x16.shuffle 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12',
+     `c4 e3 71 0f c1 0d         vpalignr \\$0x0D, %xmm1, %xmm1, %xmm0`],
+    ['i8x16.shuffle 28 29 30 31 0 1 2 3 4 5 6 7 8 9 10 11',
+     `c4 e3 71 0f c2 0c         vpalignr \\$0x0C, %xmm2, %xmm1, %xmm0`]]);
+
+if (isAvxPresent(2)) {
+     codegenTestX64_v128xv128_v128_avxhack([
+          // Broadcast low byte from second argument
+          ['i8x16.shuffle 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0',
+           'c4 e2 79 78 c1            vpbroadcastb %xmm1, %xmm0'],
+
+          // Broadcast low word from third argument
+          ['i8x16.shuffle 16 17 16 17 16 17 16 17 16 17 16 17 16 17 16 17',
+          'c4 e2 79 79 c2            vpbroadcastw %xmm2, %xmm0'],
+
+          // Broadcast low doubleword from second argument
+          ['i8x16.shuffle 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3',
+           'c4 e2 79 58 c1            vpbroadcastd %xmm1, %xmm0']]);
+}
+
+// Testing AVX optimization where VPBLENDVB accepts four XMM registers as args.
+codegenTestX64_adhoc(
+     `(func (export "f") (param v128 v128 v128 v128) (result v128)
+        (i8x16.shuffle 0 17 2 3 4 5 6 7 24 25 26 11 12 13 30 15
+          (local.get 2)(local.get 3)))`,
+     'f',
+`
+66 0f 6f 0d ${RIPRADDR}   movdqax ${RIPR}, %xmm1
+c4 e3 69 4c c3 10         vpblendvb %xmm1, %xmm3, %xmm2, %xmm0`);
+
+// Constant arguments that are folded into the instruction
+codegenTestX64_v128xLITERAL_v128_avxhack(
+     [['i8x16.add', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 fc 05 ${RIPRADDR}   vpaddbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.sub', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 f8 05 ${RIPRADDR}   vpsubbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.add_sat_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 ec 05 ${RIPRADDR}   vpaddsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.add_sat_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 dc 05 ${RIPRADDR}   vpaddusbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.sub_sat_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 e8 05 ${RIPRADDR}   vpsubsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.sub_sat_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 d8 05 ${RIPRADDR}   vpsubusbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.min_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 38 05 ${RIPRADDR} vpminsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.min_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 da 05 ${RIPRADDR}   vpminubx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.max_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 3c 05 ${RIPRADDR} vpmaxsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.max_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 de 05 ${RIPRADDR}   vpmaxubx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.eq', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 74 05 ${RIPRADDR}   vpcmpeqbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.ne', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)', `
+ c5 f1 74 05 ${RIPRADDR}   vpcmpeqbx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i8x16.gt_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 64 05 ${RIPRADDR}   vpcmpgtbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.le_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)', `
+ c5 f1 64 05 ${RIPRADDR}   vpcmpgtbx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i8x16.narrow_i16x8_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 63 05 ${RIPRADDR}  vpacksswbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.narrow_i16x8_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 67 05 ${RIPRADDR}  vpackuswbx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['i16x8.add', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 fd 05 ${RIPRADDR}  vpaddwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.sub', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 f9 05 ${RIPRADDR}  vpsubwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.mul', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 d5 05 ${RIPRADDR}  vpmullwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.add_sat_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 ed 05 ${RIPRADDR}  vpaddswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.add_sat_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 dd 05 ${RIPRADDR}  vpadduswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.sub_sat_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 e9 05 ${RIPRADDR}  vpsubswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.sub_sat_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 d9 05 ${RIPRADDR}  vpsubuswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.min_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 ea 05 ${RIPRADDR}  vpminswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.min_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 3a 05 ${RIPRADDR} vpminuwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.max_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 ee 05 ${RIPRADDR}  vpmaxswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.max_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 3e 05 ${RIPRADDR} vpmaxuwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.eq', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 75 05 ${RIPRADDR}  vpcmpeqwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.ne', '(v128.const i16x8 1 2 1 2 1 2 1 2)', `
+ c5 f1 75 05 ${RIPRADDR}  vpcmpeqwx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i16x8.gt_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 65 05 ${RIPRADDR}  vpcmpgtwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.le_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)', `
+ c5 f1 65 05 ${RIPRADDR}  vpcmpgtwx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i16x8.narrow_i32x4_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 6b 05 ${RIPRADDR}  vpackssdwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.narrow_i32x4_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 2b 05 ${RIPRADDR} vpackusdwx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['i32x4.add', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 fe 05 ${RIPRADDR}  vpadddx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.sub', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 fa 05 ${RIPRADDR}  vpsubdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.mul', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 40 05 ${RIPRADDR} vpmulldx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.min_s', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 39 05 ${RIPRADDR} vpminsdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.min_u', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 3b 05 ${RIPRADDR} vpminudx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.max_s', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 3d 05 ${RIPRADDR} vpmaxsdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.max_u', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 3f 05 ${RIPRADDR} vpmaxudx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.eq', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 76 05 ${RIPRADDR}  vpcmpeqdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.ne', '(v128.const i32x4 1 2 1 2)', `
+ c5 f1 76 05 ${RIPRADDR}  vpcmpeqdx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i32x4.gt_s', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 66 05 ${RIPRADDR}  vpcmpgtdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.le_s', '(v128.const i32x4 1 2 1 2)', `
+ c5 f1 66 05 ${RIPRADDR}  vpcmpgtdx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i32x4.dot_i16x8_s', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 f5 05 ${RIPRADDR}  vpmaddwdx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['i64x2.add', '(v128.const i64x2 1 2)',
+       `c5 f1 d4 05 ${RIPRADDR}  vpaddqx ${RIPR}, %xmm1, %xmm0`],
+      ['i64x2.sub', '(v128.const i64x2 1 2)',
+       `c5 f1 fb 05 ${RIPRADDR}  vpsubqx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['v128.and', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 db 05 ${RIPRADDR}  vpandx ${RIPR}, %xmm1, %xmm0`],
+      ['v128.or', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 eb 05 ${RIPRADDR}  vporx ${RIPR}, %xmm1, %xmm0`],
+      ['v128.xor', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 ef 05 ${RIPRADDR}  vpxorx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['f32x4.add', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 58 05 ${RIPRADDR}      vaddpsx ${RIPR}, %xmm1, %xmm0`],
+      ['f32x4.sub', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 5c 05 ${RIPRADDR}      vsubpsx ${RIPR}, %xmm1, %xmm0`],
+      ['f32x4.mul', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 59 05 ${RIPRADDR}      vmulpsx ${RIPR}, %xmm1, %xmm0`],
+      ['f32x4.div', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 5e 05 ${RIPRADDR}      vdivpsx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['f64x2.add', '(v128.const f64x2 1 2)',
+       `c5 f1 58 05 ${RIPRADDR}      vaddpdx ${RIPR}, %xmm1, %xmm0`],
+      ['f64x2.sub', '(v128.const f64x2 1 2)',
+       `c5 f1 5c 05 ${RIPRADDR}      vsubpdx ${RIPR}, %xmm1, %xmm0`],
+      ['f64x2.mul', '(v128.const f64x2 1 2)',
+       `c5 f1 59 05 ${RIPRADDR}      vmulpdx ${RIPR}, %xmm1, %xmm0`],
+      ['f64x2.div', '(v128.const f64x2 1 2)',
+       `c5 f1 5e 05 ${RIPRADDR}      vdivpdx ${RIPR}, %xmm1, %xmm0`],
+
+      ['f32x4.eq', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 c2 05 ${RIPRADDR} 00   vcmppsx \\$0x00, ${RIPR}, %xmm1, %xmm0`],
+      ['f32x4.ne', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 c2 05 ${RIPRADDR} 04   vcmppsx \\$0x04, ${RIPR}, %xmm1, %xmm0`],
+      ['f32x4.lt', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 c2 05 ${RIPRADDR} 01   vcmppsx \\$0x01, ${RIPR}, %xmm1, %xmm0`],
+      ['f32x4.le', '(v128.const f32x4 1 2 3 4)',
+       `c5 f0 c2 05 ${RIPRADDR} 02   vcmppsx \\$0x02, ${RIPR}, %xmm1, %xmm0`],
+
+      ['f64x2.eq', '(v128.const f64x2 1 2)',
+       `c5 f1 c2 05 ${RIPRADDR} 00  vcmppdx \\$0x00, ${RIPR}, %xmm1, %xmm0`],
+      ['f64x2.ne', '(v128.const f64x2 1 2)',
+       `c5 f1 c2 05 ${RIPRADDR} 04  vcmppdx \\$0x04, ${RIPR}, %xmm1, %xmm0`],
+      ['f64x2.lt', '(v128.const f64x2 1 2)',
+       `c5 f1 c2 05 ${RIPRADDR} 01  vcmppdx \\$0x01, ${RIPR}, %xmm1, %xmm0`],
+      ['f64x2.le', '(v128.const f64x2 1 2)',
+       `c5 f1 c2 05 ${RIPRADDR} 02  vcmppdx \\$0x02, ${RIPR}, %xmm1, %xmm0`]]);
+ 
+ // Commutative operations with constants on the lhs should generate the same
+ // code as with the constant on the rhs.
+ codegenTestX64_LITERALxv128_v128_avxhack(
+     [['i8x16.add', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 fc 05 ${RIPRADDR}  vpaddbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.add_sat_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 ec 05 ${RIPRADDR}  vpaddsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.add_sat_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 dc 05 ${RIPRADDR}  vpaddusbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.min_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 38 05 ${RIPRADDR} vpminsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.min_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 da 05 ${RIPRADDR}  vpminubx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.max_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 3c 05 ${RIPRADDR} vpmaxsbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.max_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 de 05 ${RIPRADDR}  vpmaxubx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.eq', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 74 05 ${RIPRADDR}  vpcmpeqbx ${RIPR}, %xmm1, %xmm0`],
+      ['i8x16.ne', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)', `
+ c5 f1 74 05 ${RIPRADDR}  vpcmpeqbx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+ 
+      ['i16x8.add', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 fd 05 ${RIPRADDR}  vpaddwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.mul', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 d5 05 ${RIPRADDR}  vpmullwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.add_sat_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 ed 05 ${RIPRADDR}  vpaddswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.add_sat_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 dd 05 ${RIPRADDR}  vpadduswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.min_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 ea 05 ${RIPRADDR}  vpminswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.min_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 3a 05 ${RIPRADDR} vpminuwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.max_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 ee 05 ${RIPRADDR}  vpmaxswx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.max_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c4 e2 71 3e 05 ${RIPRADDR} vpmaxuwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.eq', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+       `c5 f1 75 05 ${RIPRADDR}  vpcmpeqwx ${RIPR}, %xmm1, %xmm0`],
+      ['i16x8.ne', '(v128.const i16x8 1 2 1 2 1 2 1 2)', `
+ c5 f1 75 05 ${RIPRADDR}  vpcmpeqwx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+ 
+      ['i32x4.add', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 fe 05 ${RIPRADDR}  vpadddx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.mul', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 40 05 ${RIPRADDR} vpmulldx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.min_s', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 39 05 ${RIPRADDR} vpminsdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.min_u', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 3b 05 ${RIPRADDR} vpminudx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.max_s', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 3d 05 ${RIPRADDR} vpmaxsdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.max_u', '(v128.const i32x4 1 2 1 2)',
+       `c4 e2 71 3f 05 ${RIPRADDR} vpmaxudx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.eq', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 76 05 ${RIPRADDR}  vpcmpeqdx ${RIPR}, %xmm1, %xmm0`],
+      ['i32x4.ne', '(v128.const i32x4 1 2 1 2)', `
+ c5 f1 76 05 ${RIPRADDR}  vpcmpeqdx ${RIPR}, %xmm1, %xmm0
+ 66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+ 66 41 0f ef c7            pxor %xmm15, %xmm0`],
+      ['i32x4.dot_i16x8_s', '(v128.const i32x4 1 2 1 2)',
+       `c5 f1 f5 05 ${RIPRADDR}  vpmaddwdx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['i64x2.add', '(v128.const i64x2 1 2)',
+       `c5 f1 d4 05 ${RIPRADDR}  vpaddqx ${RIPR}, %xmm1, %xmm0`],
+ 
+      ['v128.and', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 db 05 ${RIPRADDR}  vpandx ${RIPR}, %xmm1, %xmm0`],
+      ['v128.or', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 eb 05 ${RIPRADDR}  vporx ${RIPR}, %xmm1, %xmm0`],
+      ['v128.xor', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+       `c5 f1 ef 05 ${RIPRADDR}  vpxorx ${RIPR}, %xmm1, %xmm0`]]);
+
+// Shift by constant encodings
+codegenTestX64_v128xLITERAL_v128_avxhack(
+     [['i8x16.shl', '(i32.const 2)', `
+c5 f1 fc c1               vpaddb %xmm1, %xmm1, %xmm0
+66 0f fc c0               paddb %xmm0, %xmm0`],
+      ['i8x16.shl', '(i32.const 4)', `
+c5 f1 db 05 ${RIPRADDR}   vpandx ${RIPR}, %xmm1, %xmm0
+66 0f 71 f0 04            psllw \\$0x04, %xmm0`],
+      ['i16x8.shl', '(i32.const 1)',
+       'c5 f9 71 f1 01            vpsllw \\$0x01, %xmm1, %xmm0'],
+      ['i16x8.shr_s', '(i32.const 3)',
+       'c5 f9 71 e1 03            vpsraw \\$0x03, %xmm1, %xmm0'],
+      ['i16x8.shr_u', '(i32.const 2)',
+       'c5 f9 71 d1 02            vpsrlw \\$0x02, %xmm1, %xmm0'], 
+      ['i32x4.shl', '(i32.const 5)',
+       'c5 f9 72 f1 05            vpslld \\$0x05, %xmm1, %xmm0'],
+      ['i32x4.shr_s', '(i32.const 2)',
+       'c5 f9 72 e1 02            vpsrad \\$0x02, %xmm1, %xmm0'],
+      ['i32x4.shr_u', '(i32.const 5)',
+       'c5 f9 72 d1 05            vpsrld \\$0x05, %xmm1, %xmm0'],
+      ['i64x2.shr_s', '(i32.const 7)', `
+c5 79 70 f9 f5            vpshufd \\$0xF5, %xmm1, %xmm15
+66 41 0f 72 e7 1f         psrad \\$0x1F, %xmm15
+c4 c1 71 ef c7            vpxor %xmm15, %xmm1, %xmm0
+66 0f 73 d0 07            psrlq \\$0x07, %xmm0
+66 41 0f ef c7            pxor %xmm15, %xmm0`]]);
+
+// vpblendvp optimization when bitselect follows comparison.
+codegenTestX64_adhoc(
+     `(module
+         (func (export "f") (param v128) (param v128) (param v128) (param v128) (result v128)
+           (v128.bitselect (local.get 2) (local.get 3)
+              (i32x4.eq (local.get 0) (local.get 1)))))`,
+         'f', `
+66 0f 76 c1               pcmpeqd %xmm1, %xmm0
+c4 e3 61 4c c2 00         vpblendvb %xmm0, %xmm2, %xmm3, %xmm0`);
diff --git a/js/src/jit-test/tests/wasm/simd/baseline-bug1636235.js b/js/src/jit-test/tests/wasm/simd/baseline-bug1636235.js
new file mode 100644
index 0000000000..da1fb68e6b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/baseline-bug1636235.js
@@ -0,0 +1,111 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Bug 1636235: assorted corner case baseline SIMD bugs.
+
+function get(arr, loc, len) {
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        res.push(arr[loc+i]);
+    }
+    return res;
+}
+
+// Pass v128 along a control flow edge in br_table
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "run") (param $k i32)
+      (v128.store (i32.const 0) (call $f (local.get $k))))
+    (func $f (param $k i32) (result v128)
+      (block $B2 (result v128)
+        (block $B1 (result v128)
+          (v128.const i32x4 1 2 3 4)
+          (br_table $B1 $B2 (local.get $k)))
+        (drop)
+        (v128.const i32x4 5 6 7 8))))`);
+
+var mem = new Int32Array(ins.exports.mem.buffer);
+ins.exports.run(0);
+assertDeepEq(get(mem, 0, 4), [5, 6, 7, 8]);
+
+ins.exports.run(1);
+assertDeepEq(get(mem, 0, 4), [1, 2, 3, 4]);
+
+// Materialize a ConstV128 off the value stack in popStackResults (also: check
+// that br passing v128 values works as it should).
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+
+    (func (export "run") (param $k i32)
+      (local $t0 v128) (local $t1 v128) (local $t2 v128)
+      (call $f (local.get $k))
+      (local.set $t2)
+      (local.set $t1)
+      (local.set $t0)
+      (v128.store (i32.const 32) (local.get $t2))
+      (v128.store (i32.const 16) (local.get $t1))
+      (v128.store (i32.const 0) (local.get $t0)))
+
+    (func $f (param $k i32) (result v128 v128 v128)
+      (block $B2 (result v128 v128 v128)
+        (if (local.get $k)
+            (br $B2 (v128.const i32x4 5 6 7 8)
+                    (v128.const i32x4 9 10 11 12)
+                    (v128.const i32x4 13 14 15 16))
+            (br $B2 (v128.const i32x4 -5 -6 -7 -8)
+                    (v128.const i32x4 -9 -10 -11 -12)
+                    (v128.const i32x4 -13 -14 -15 -16)))
+        (unreachable))))`);
+
+var mem = new Int32Array(ins.exports.mem.buffer);
+ins.exports.run(0);
+assertDeepEq(get(mem, 0, 4), [-5, -6, -7, -8]);
+assertDeepEq(get(mem, 4, 4), [-9, -10, -11, -12]);
+assertDeepEq(get(mem, 8, 4), [-13, -14, -15, -16]);
+
+ins.exports.run(1);
+assertDeepEq(get(mem, 0, 4), [5, 6, 7, 8]);
+assertDeepEq(get(mem, 4, 4), [9, 10, 11, 12]);
+assertDeepEq(get(mem, 8, 4), [13, 14, 15, 16]);
+
+// Check that br_if passing v128 values works as it should.
+
+var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+
+    (func (export "run") (param $k i32)
+      (local $t0 v128) (local $t1 v128) (local $t2 v128)
+      (call $f (local.get $k))
+      (local.set $t2)
+      (local.set $t1)
+      (local.set $t0)
+      (v128.store (i32.const 32) (local.get $t2))
+      (v128.store (i32.const 16) (local.get $t1))
+      (v128.store (i32.const 0) (local.get $t0)))
+
+    (func $f (param $k i32) (result v128 v128 v128)
+      (block $B2 (result v128 v128 v128)
+        (v128.const i32x4 5 6 7 8)
+        (v128.const i32x4 9 10 11 12)
+        (v128.const i32x4 13 14 15 16)
+        (br_if $B2 (local.get $k))
+        drop drop drop
+        (v128.const i32x4 -5 -6 -7 -8)
+        (v128.const i32x4 -9 -10 -11 -12)
+        (v128.const i32x4 -13 -14 -15 -16))))`);
+
+var mem = new Int32Array(ins.exports.mem.buffer);
+ins.exports.run(0);
+assertDeepEq(get(mem, 0, 4), [-5, -6, -7, -8]);
+assertDeepEq(get(mem, 4, 4), [-9, -10, -11, -12]);
+assertDeepEq(get(mem, 8, 4), [-13, -14, -15, -16]);
+
+ins.exports.run(1);
+assertDeepEq(get(mem, 0, 4), [5, 6, 7, 8]);
+assertDeepEq(get(mem, 4, 4), [9, 10, 11, 12]);
+assertDeepEq(get(mem, 8, 4), [13, 14, 15, 16]);
+
diff --git a/js/src/jit-test/tests/wasm/simd/binop-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/binop-x64-ion-codegen.js
new file mode 100644
index 0000000000..17c15e22d5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/binop-x64-ion-codegen.js
@@ -0,0 +1,255 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// Test that there are no extraneous moves or fixups for sundry SIMD binary
+// operations.  See README-codegen.md for general information about this type of
+// test case.
+
+// Inputs (xmm0, xmm1)
+
+codegenTestX64_v128xPTYPE_v128(
+    [['f32x4.replace_lane 0', 'f32', `f3 0f 10 c1               movss %xmm1, %xmm0`],
+     ['f32x4.replace_lane 1', 'f32', `66 0f 3a 21 c1 10         insertps \\$0x10, %xmm1, %xmm0`],
+     ['f32x4.replace_lane 3', 'f32', `66 0f 3a 21 c1 30         insertps \\$0x30, %xmm1, %xmm0`],
+     ['f64x2.replace_lane 0', 'f64', `f2 0f 10 c1               movsd %xmm1, %xmm0`],
+     ['f64x2.replace_lane 1', 'f64', `66 0f c6 c1 00            shufpd \\$0x00, %xmm1, %xmm0`]] );
+
+// Inputs (xmm1, xmm0)
+
+codegenTestX64_v128xv128_v128_reversed(
+    [['f32x4.pmin', `0f 5d c1                  minps %xmm1, %xmm0`],
+     ['f32x4.pmax', `0f 5f c1                  maxps %xmm1, %xmm0`],
+     ['f64x2.pmin', `66 0f 5d c1               minpd %xmm1, %xmm0`],
+     ['f64x2.pmax', `66 0f 5f c1               maxpd %xmm1, %xmm0`]] );
+
+// Constant arguments that are folded into the instruction
+
+codegenTestX64_v128xLITERAL_v128(
+    [['i8x16.add', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f fc 05 ${RIPRADDR}   paddbx ${RIPR}, %xmm0`],
+     ['i8x16.sub', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f f8 05 ${RIPRADDR}   psubbx ${RIPR}, %xmm0`],
+     ['i8x16.add_sat_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f ec 05 ${RIPRADDR}   paddsbx ${RIPR}, %xmm0`],
+     ['i8x16.add_sat_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f dc 05 ${RIPRADDR}   paddusbx ${RIPR}, %xmm0`],
+     ['i8x16.sub_sat_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f e8 05 ${RIPRADDR}   psubsbx ${RIPR}, %xmm0`],
+     ['i8x16.sub_sat_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f d8 05 ${RIPRADDR}   psubusbx ${RIPR}, %xmm0`],
+     ['i8x16.min_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 38 38 05 ${RIPRADDR} pminsbx ${RIPR}, %xmm0`],
+     ['i8x16.min_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f da 05 ${RIPRADDR}   pminubx ${RIPR}, %xmm0`],
+     ['i8x16.max_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 38 3c 05 ${RIPRADDR} pmaxsbx ${RIPR}, %xmm0`],
+     ['i8x16.max_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f de 05 ${RIPRADDR}   pmaxubx ${RIPR}, %xmm0`],
+     ['i8x16.eq', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 74 05 ${RIPRADDR}   pcmpeqbx ${RIPR}, %xmm0`],
+     ['i8x16.ne', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)', `
+66 0f 74 05 ${RIPRADDR}   pcmpeqbx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i8x16.gt_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 64 05 ${RIPRADDR}   pcmpgtbx ${RIPR}, %xmm0`],
+     ['i8x16.le_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)', `
+66 0f 64 05 ${RIPRADDR}   pcmpgtbx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i8x16.narrow_i16x8_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 63 05 ${RIPRADDR}   packsswbx ${RIPR}, %xmm0`],
+     ['i8x16.narrow_i16x8_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 67 05 ${RIPRADDR}   packuswbx ${RIPR}, %xmm0`],
+
+     ['i16x8.add', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f fd 05 ${RIPRADDR}   paddwx ${RIPR}, %xmm0`],
+     ['i16x8.sub', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f f9 05 ${RIPRADDR}   psubwx ${RIPR}, %xmm0`],
+     ['i16x8.mul', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f d5 05 ${RIPRADDR}   pmullwx ${RIPR}, %xmm0`],
+     ['i16x8.add_sat_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f ed 05 ${RIPRADDR}   paddswx ${RIPR}, %xmm0`],
+     ['i16x8.add_sat_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f dd 05 ${RIPRADDR}   padduswx ${RIPR}, %xmm0`],
+     ['i16x8.sub_sat_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f e9 05 ${RIPRADDR}   psubswx ${RIPR}, %xmm0`],
+     ['i16x8.sub_sat_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f d9 05 ${RIPRADDR}   psubuswx ${RIPR}, %xmm0`],
+     ['i16x8.min_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f ea 05 ${RIPRADDR}   pminswx ${RIPR}, %xmm0`],
+     ['i16x8.min_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 38 3a 05 ${RIPRADDR} pminuwx ${RIPR}, %xmm0`],
+     ['i16x8.max_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f ee 05 ${RIPRADDR}   pmaxswx ${RIPR}, %xmm0`],
+     ['i16x8.max_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 38 3e 05 ${RIPRADDR} pmaxuwx ${RIPR}, %xmm0`],
+     ['i16x8.eq', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 75 05 ${RIPRADDR}   pcmpeqwx ${RIPR}, %xmm0`],
+     ['i16x8.ne', '(v128.const i16x8 1 2 1 2 1 2 1 2)', `
+66 0f 75 05 ${RIPRADDR}   pcmpeqwx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i16x8.gt_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 65 05 ${RIPRADDR}   pcmpgtwx ${RIPR}, %xmm0`],
+     ['i16x8.le_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)', `
+66 0f 65 05 ${RIPRADDR}   pcmpgtwx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i16x8.narrow_i32x4_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 6b 05 ${RIPRADDR}   packssdwx ${RIPR}, %xmm0`],
+     ['i16x8.narrow_i32x4_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 38 2b 05 ${RIPRADDR} packusdwx ${RIPR}, %xmm0`],
+
+     ['i32x4.add', '(v128.const i32x4 1 2 1 2)',
+      `66 0f fe 05 ${RIPRADDR}   padddx ${RIPR}, %xmm0`],
+     ['i32x4.sub', '(v128.const i32x4 1 2 1 2)',
+      `66 0f fa 05 ${RIPRADDR}   psubdx ${RIPR}, %xmm0`],
+     ['i32x4.mul', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 40 05 ${RIPRADDR} pmulldx ${RIPR}, %xmm0`],
+     ['i32x4.min_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 39 05 ${RIPRADDR} pminsdx ${RIPR}, %xmm0`],
+     ['i32x4.min_u', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 3b 05 ${RIPRADDR} pminudx ${RIPR}, %xmm0`],
+     ['i32x4.max_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 3d 05 ${RIPRADDR} pmaxsdx ${RIPR}, %xmm0`],
+     ['i32x4.max_u', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 3f 05 ${RIPRADDR} pmaxudx ${RIPR}, %xmm0`],
+     ['i32x4.eq', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 76 05 ${RIPRADDR}   pcmpeqdx ${RIPR}, %xmm0`],
+     ['i32x4.ne', '(v128.const i32x4 1 2 1 2)', `
+66 0f 76 05 ${RIPRADDR}   pcmpeqdx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i32x4.gt_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 66 05 ${RIPRADDR}   pcmpgtdx ${RIPR}, %xmm0`],
+     ['i32x4.le_s', '(v128.const i32x4 1 2 1 2)', `
+66 0f 66 05 ${RIPRADDR}   pcmpgtdx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i32x4.dot_i16x8_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f f5 05 ${RIPRADDR}   pmaddwdx ${RIPR}, %xmm0`],
+
+     ['i64x2.add', '(v128.const i64x2 1 2)',
+      `66 0f d4 05 ${RIPRADDR}   paddqx ${RIPR}, %xmm0`],
+     ['i64x2.sub', '(v128.const i64x2 1 2)',
+      `66 0f fb 05 ${RIPRADDR}   psubqx ${RIPR}, %xmm0`],
+
+     ['v128.and', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f db 05 ${RIPRADDR}   pandx ${RIPR}, %xmm0`],
+     ['v128.or', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f eb 05 ${RIPRADDR}   porx ${RIPR}, %xmm0`],
+     ['v128.xor', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f ef 05 ${RIPRADDR}   pxorx ${RIPR}, %xmm0`],
+
+     ['f32x4.add', '(v128.const f32x4 1 2 3 4)',
+      `0f 58 05 ${RIPRADDR}      addpsx ${RIPR}, %xmm0`],
+     ['f32x4.sub', '(v128.const f32x4 1 2 3 4)',
+      `0f 5c 05 ${RIPRADDR}      subpsx ${RIPR}, %xmm0`],
+     ['f32x4.mul', '(v128.const f32x4 1 2 3 4)',
+      `0f 59 05 ${RIPRADDR}      mulpsx ${RIPR}, %xmm0`],
+     ['f32x4.div', '(v128.const f32x4 1 2 3 4)',
+      `0f 5e 05 ${RIPRADDR}      divpsx ${RIPR}, %xmm0`],
+     ['f32x4.eq', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${RIPRADDR} 00   cmppsx \\$0x00, ${RIPR}, %xmm0`],
+     ['f32x4.ne', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${RIPRADDR} 04   cmppsx \\$0x04, ${RIPR}, %xmm0`],
+     ['f32x4.lt', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${RIPRADDR} 01   cmppsx \\$0x01, ${RIPR}, %xmm0`],
+     ['f32x4.le', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${RIPRADDR} 02   cmppsx \\$0x02, ${RIPR}, %xmm0`],
+
+     ['f64x2.add', '(v128.const f64x2 1 2)',
+      `66 0f 58 05 ${RIPRADDR}      addpdx ${RIPR}, %xmm0`],
+     ['f64x2.sub', '(v128.const f64x2 1 2)',
+      `66 0f 5c 05 ${RIPRADDR}      subpdx ${RIPR}, %xmm0`],
+     ['f64x2.mul', '(v128.const f64x2 1 2)',
+      `66 0f 59 05 ${RIPRADDR}      mulpdx ${RIPR}, %xmm0`],
+     ['f64x2.div', '(v128.const f64x2 1 2)',
+      `66 0f 5e 05 ${RIPRADDR}      divpdx ${RIPR}, %xmm0`],
+     ['f64x2.eq', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${RIPRADDR} 00   cmppdx \\$0x00, ${RIPR}, %xmm0`],
+     ['f64x2.ne', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${RIPRADDR} 04   cmppdx \\$0x04, ${RIPR}, %xmm0`],
+     ['f64x2.lt', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${RIPRADDR} 01   cmppdx \\$0x01, ${RIPR}, %xmm0`],
+     ['f64x2.le', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${RIPRADDR} 02   cmppdx \\$0x02, ${RIPR}, %xmm0`]]);
+
+// Commutative operations with constants on the lhs should generate the same
+// code as with the constant on the rhs.
+
+codegenTestX64_LITERALxv128_v128(
+    [['i8x16.add', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f fc 05 ${RIPRADDR}   paddbx ${RIPR}, %xmm0`],
+     ['i8x16.add_sat_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f ec 05 ${RIPRADDR}   paddsbx ${RIPR}, %xmm0`],
+     ['i8x16.add_sat_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f dc 05 ${RIPRADDR}   paddusbx ${RIPR}, %xmm0`],
+     ['i8x16.min_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 38 38 05 ${RIPRADDR} pminsbx ${RIPR}, %xmm0`],
+     ['i8x16.min_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f da 05 ${RIPRADDR}   pminubx ${RIPR}, %xmm0`],
+     ['i8x16.max_s', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 38 3c 05 ${RIPRADDR} pmaxsbx ${RIPR}, %xmm0`],
+     ['i8x16.max_u', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f de 05 ${RIPRADDR}   pmaxubx ${RIPR}, %xmm0`],
+     ['i8x16.eq', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f 74 05 ${RIPRADDR}   pcmpeqbx ${RIPR}, %xmm0`],
+     ['i8x16.ne', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)', `
+66 0f 74 05 ${RIPRADDR}   pcmpeqbx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+
+     ['i16x8.add', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f fd 05 ${RIPRADDR}   paddwx ${RIPR}, %xmm0`],
+     ['i16x8.mul', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f d5 05 ${RIPRADDR}   pmullwx ${RIPR}, %xmm0`],
+     ['i16x8.add_sat_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f ed 05 ${RIPRADDR}   paddswx ${RIPR}, %xmm0`],
+     ['i16x8.add_sat_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f dd 05 ${RIPRADDR}   padduswx ${RIPR}, %xmm0`],
+     ['i16x8.min_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f ea 05 ${RIPRADDR}   pminswx ${RIPR}, %xmm0`],
+     ['i16x8.min_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 38 3a 05 ${RIPRADDR} pminuwx ${RIPR}, %xmm0`],
+     ['i16x8.max_s', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f ee 05 ${RIPRADDR}   pmaxswx ${RIPR}, %xmm0`],
+     ['i16x8.max_u', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 38 3e 05 ${RIPRADDR} pmaxuwx ${RIPR}, %xmm0`],
+     ['i16x8.eq', '(v128.const i16x8 1 2 1 2 1 2 1 2)',
+      `66 0f 75 05 ${RIPRADDR}   pcmpeqwx ${RIPR}, %xmm0`],
+     ['i16x8.ne', '(v128.const i16x8 1 2 1 2 1 2 1 2)', `
+66 0f 75 05 ${RIPRADDR}   pcmpeqwx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+
+     ['i32x4.add', '(v128.const i32x4 1 2 1 2)',
+      `66 0f fe 05 ${RIPRADDR}   padddx ${RIPR}, %xmm0`],
+     ['i32x4.mul', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 40 05 ${RIPRADDR} pmulldx ${RIPR}, %xmm0`],
+     ['i32x4.min_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 39 05 ${RIPRADDR} pminsdx ${RIPR}, %xmm0`],
+     ['i32x4.min_u', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 3b 05 ${RIPRADDR} pminudx ${RIPR}, %xmm0`],
+     ['i32x4.max_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 3d 05 ${RIPRADDR} pmaxsdx ${RIPR}, %xmm0`],
+     ['i32x4.max_u', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 38 3f 05 ${RIPRADDR} pmaxudx ${RIPR}, %xmm0`],
+     ['i32x4.eq', '(v128.const i32x4 1 2 1 2)',
+      `66 0f 76 05 ${RIPRADDR}   pcmpeqdx ${RIPR}, %xmm0`],
+     ['i32x4.ne', '(v128.const i32x4 1 2 1 2)', `
+66 0f 76 05 ${RIPRADDR}   pcmpeqdx ${RIPR}, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i32x4.dot_i16x8_s', '(v128.const i32x4 1 2 1 2)',
+      `66 0f f5 05 ${RIPRADDR}   pmaddwdx ${RIPR}, %xmm0`],
+
+     ['i64x2.add', '(v128.const i64x2 1 2)',
+      `66 0f d4 05 ${RIPRADDR}   paddqx ${RIPR}, %xmm0`],
+
+     ['v128.and', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f db 05 ${RIPRADDR}   pandx ${RIPR}, %xmm0`],
+     ['v128.or', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f eb 05 ${RIPRADDR}   porx ${RIPR}, %xmm0`],
+     ['v128.xor', '(v128.const i8x16 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2)',
+      `66 0f ef 05 ${RIPRADDR}   pxorx ${RIPR}, %xmm0`]]);
diff --git a/js/src/jit-test/tests/wasm/simd/binop-x86-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/binop-x86-ion-codegen.js
new file mode 100644
index 0000000000..2cb5f2e969
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/binop-x86-ion-codegen.js
@@ -0,0 +1,20 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x86 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x86-test.js
+
+codegenTestX86_v128xLITERAL_v128(
+    [['f32x4.eq', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${ABSADDR} 00   cmppsx \\$0x00, ${ABS}, %xmm0`],
+     ['f32x4.ne', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${ABSADDR} 04   cmppsx \\$0x04, ${ABS}, %xmm0`],
+     ['f32x4.lt', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${ABSADDR} 01   cmppsx \\$0x01, ${ABS}, %xmm0`],
+     ['f32x4.le', '(v128.const f32x4 1 2 3 4)',
+      `0f c2 05 ${ABSADDR} 02   cmppsx \\$0x02, ${ABS}, %xmm0`],
+
+     ['f64x2.eq', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${ABSADDR} 00   cmppdx \\$0x00, ${ABS}, %xmm0`],
+     ['f64x2.ne', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${ABSADDR} 04   cmppdx \\$0x04, ${ABS}, %xmm0`],
+     ['f64x2.lt', '(v128.const f64x2 1 2)',
+      `66 0f c2 05 ${ABSADDR} 01   cmppdx \\$0x01, ${ABS}, %xmm0`],
+     ['f64x2.le', '(v128.const f64x2 1 2)',
+     `66 0f c2 05 ${ABSADDR} 02   cmppdx \\$0x02, ${ABS}, %xmm0`]]);
diff --git a/js/src/jit-test/tests/wasm/simd/bitselect-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/bitselect-x64-ion-codegen.js
new file mode 100644
index 0000000000..62951bce62
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/bitselect-x64-ion-codegen.js
@@ -0,0 +1,45 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x64-test.js
+
+// Test that there are no extraneous moves or fixups for SIMD bitselect
+// operations.  See README-codegen.md for general information about this type of
+// test case.
+
+// The codegen enforces onTrue == output so we avoid a move to set that up.
+//
+// The remaining movdqa is currently unavoidable, it moves the control mask into a temp.
+// The temp should be identical to the mask but the regalloc does not currently
+// allow this constraint to be enforced.
+
+// Inputs (xmm0, xmm1, xmm2)
+
+codegenTestX64_adhoc(
+`(module
+    (func (export "f") (param v128) (param v128) (param v128) (param v128) (result v128)
+      (v128.bitselect (local.get 0) (local.get 1) (local.get 2))))`,
+    'f',
+`66 0f 6f da               movdqa %xmm2, %xmm3
+66 0f db c3               pand %xmm3, %xmm0
+66 0f df d9               pandn %xmm1, %xmm3
+66 0f eb c3               por %xmm3, %xmm0`);
+
+// Blend constant optimizations
+
+codegenTestX64_adhoc(
+  `(module
+      (func (export "f") (param v128) (param v128) (param v128) (result v128)
+        (v128.bitselect (local.get 0) (local.get 1) (v128.const i32x4 -1 0 0 -1))))`,
+      'f',
+  `66 0f 3a 0e c1 c3         pblendw \\$0xC3, %xmm1, %xmm0`);
+  
+// vpblendvp optimization when bitselect follows comparison.
+// Non-AVX pblendvb uses xmm0 as an implicit read-only operand.
+codegenTestX64_adhoc(
+  `(module
+      (func (export "f") (param v128) (param v128) (param v128) (param v128) (result v128)
+        (v128.bitselect (local.get 2) (local.get 3)
+           (i32x4.eq (local.get 0) (local.get 1)))))`,
+      'f', `
+66 0f 76 c1               pcmpeqd %xmm1, %xmm0
+66 0f 6f cb               movdqa %xmm3, %xmm1
+66 0f 38 10 ca            pblendvb %xmm2, %xmm1
+66 0f 6f c1               movdqa %xmm1, %xmm0`);
diff --git a/js/src/jit-test/tests/wasm/simd/cmp-bitselect.js b/js/src/jit-test/tests/wasm/simd/cmp-bitselect.js
new file mode 100644
index 0000000000..0629455b71
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/cmp-bitselect.js
@@ -0,0 +1,107 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+// Tests if combination of comparsion and bitselect produces correct result.
+// On x86/64 platforms, it is expected to replace slow bitselect emulation,
+// with its faster laneselect equivalent (pblendvb).
+// See bug 1751488 for more information.
+
+let verifyCodegen = _method => {};
+if (hasDisassembler() && wasmCompileMode() == "ion" &&
+    getBuildConfiguration().x64 && !getBuildConfiguration().simulator) {
+  if (isAvxPresent()) {
+    verifyCodegen = method => {
+        assertEq(wasmDis(method, {asString: true}).includes('vpblendvb'), true);
+    };
+  } else {
+    verifyCodegen = method => {
+        assertEq(wasmDis(method, {asString: true}).includes("pblendvb"), true);
+    };
+  }
+}
+
+const checkOps = {
+  eq(a, b) { return a == b; },
+  ne(a, b) { return a != b; },
+  lt(a, b) { return a < b; },
+  le(a, b) { return a <= b; },
+  gt(a, b) { return a > b; },
+  ge(a, b) { return a >= b; },
+};
+const checkPattern = new Uint8Array(Array(32).fill(null).map((_, i) => i));
+
+for (let [laneSize, aty_s, aty_u] of [
+    [8, Int8Array, Uint8Array], [16, Int16Array, Uint16Array],
+    [32, Int32Array, Uint32Array], [64, BigInt64Array, BigUint64Array]]) {
+    const laneCount = 128 / laneSize; 
+    const ty = `i${laneSize}x${laneCount}`;
+    for (let op of ['eq', 'ne', 'lt_s', 'le_s', 'gt_s', 'ge_s', 'lt_u', 'le_u', 'gt_u', 'ge_u']) {
+        if (laneSize == 64 && op.includes('_u')) continue;
+        const wrap = laneSize < 64 ? x => x : x => BigInt(x);
+        const aty = op.includes('_u') ? aty_u : aty_s;
+        const check = checkOps[op.replace(/_[us]$/, "")];
+        // Items to test: 0, 1, all 1s, top half 1s, low half 1s, top bit 1
+        const testData = new aty([wrap(0), wrap(1), ~wrap(0), ~wrap(0) << wrap(laneSize / 2),
+                                  ~((~wrap(0)) << wrap(laneSize / 2)), wrap(1) << wrap(laneSize - 1)]);
+        const ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`(module
+            (memory (export "memory") 1)
+            (func (export "run")
+              (v128.store (i32.const 32)
+                (v128.bitselect (v128.load (i32.const 64)) (v128.load (i32.const 80)) (${ty}.${op} (v128.load (i32.const 0)) (v128.load (i32.const 16))))) ))`)));
+        const mem = new aty(ins.exports.memory.buffer);
+        const memI8 = new Uint8Array(ins.exports.memory.buffer);
+        memI8.subarray(64, 96).set(checkPattern);
+        verifyCodegen(ins.exports.run);
+        for (let i = 0; i < testData.length; i++) {
+            for (let j = 0; j < testData.length; j++) {
+                for (let q = 0; q < laneCount; q++) {
+                    mem[q] = testData[(i + q) % testData.length];
+                    mem[q + laneCount] = testData[(j + q) % testData.length];
+                }
+                ins.exports.run();
+                for (let q = 0; q < laneCount; q++) {
+                    const val = check(mem[q], mem[q + laneCount]);
+                    const n = laneSize >> 3;
+                    for (let k = 0; k < n; k++) {
+                        assertEq(checkPattern[q * n + k + (val ? 0 : 16)],
+                                 memI8[32 + q * n + k]);
+                    }
+                }
+            }
+        }
+    }
+}
+
+for (let [laneSize, aty] of [[32, Float32Array], [64, Float64Array]]) {
+    const laneCount = 128 / laneSize; 
+    const ty = `f${laneSize}x${laneCount}`;
+    for (let op of ['eq', 'ne', 'lt', 'le', 'gt', 'ge']) {
+        const check = checkOps[op];
+        // Items to test: 0, 1, -1, PI, NaN, Inf, -0, -Inf
+        const testData = new aty([0, 1, -1, Math.PI, NaN, Infinity, 0/-Infinity, -Infinity]);
+        const ins = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`(module
+            (memory (export "memory") 1)
+            (func (export "run")
+              (v128.store (i32.const 32)
+                (v128.bitselect (v128.load (i32.const 64)) (v128.load (i32.const 80)) (${ty}.${op} (v128.load (i32.const 0)) (v128.load (i32.const 16))))) ))`)));
+        const mem = new aty(ins.exports.memory.buffer);
+        const memI8 = new Uint8Array(ins.exports.memory.buffer);
+        memI8.subarray(64, 96).set(checkPattern);
+        verifyCodegen(ins.exports.run);        
+        for (let i = 0; i < testData.length; i++) {
+            for (let j = 0; j < testData.length; j++) {
+                for (let q = 0; q < laneCount; q++) {
+                    mem[q] = testData[(i + q) % testData.length];
+                    mem[q + laneCount] = testData[(j + q) % testData.length];
+                }
+                ins.exports.run();
+                for (let q = 0; q < laneCount; q++) {
+                    const val = check(mem[q], mem[q + laneCount]);
+                    const n = laneSize >> 3;
+                    for (let k = 0; k < n; k++) {
+                        assertEq(checkPattern[q * n + k + (val ? 0 : 16)],
+                                 memI8[32 + q * n + k]);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/simd/cmp-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/cmp-x64-ion-codegen.js
new file mode 100644
index 0000000000..b4fe1d0281
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/cmp-x64-ion-codegen.js
@@ -0,0 +1,77 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// Test that there are no extraneous moves or fixups for various SIMD comparison
+// operations.  See README-codegen.md for general information about this type of
+// test case.
+
+// Inputs (xmm0, xmm1)
+
+codegenTestX64_v128xv128_v128(
+    [['i8x16.gt_s', `66 0f 64 c1               pcmpgtb %xmm1, %xmm0`],
+     ['i16x8.gt_s', `66 0f 65 c1               pcmpgtw %xmm1, %xmm0`],
+     ['i32x4.gt_s', `66 0f 66 c1               pcmpgtd %xmm1, %xmm0`],
+     ['i8x16.le_s', `
+66 0f 64 c1               pcmpgtb %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0
+`],
+     ['i16x8.le_s', `
+66 0f 65 c1               pcmpgtw %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0
+`],
+     ['i32x4.le_s', `
+66 0f 66 c1               pcmpgtd %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0
+`],
+     ['i8x16.eq', `66 0f 74 c1               pcmpeqb %xmm1, %xmm0`],
+     ['i16x8.eq', `66 0f 75 c1               pcmpeqw %xmm1, %xmm0`],
+     ['i32x4.eq', `66 0f 76 c1               pcmpeqd %xmm1, %xmm0`],
+     ['i8x16.ne', `
+66 0f 74 c1               pcmpeqb %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0
+`],
+     ['i16x8.ne', `
+66 0f 75 c1               pcmpeqw %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0
+`],
+     ['i32x4.ne', `
+66 0f 76 c1               pcmpeqd %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0
+`],
+     ['f32x4.eq', `0f c2 c1 00               cmpps \\$0x00, %xmm1, %xmm0`],
+     ['f32x4.ne', `0f c2 c1 04               cmpps \\$0x04, %xmm1, %xmm0`],
+     ['f32x4.lt', `0f c2 c1 01               cmpps \\$0x01, %xmm1, %xmm0`],
+     ['f32x4.le', `0f c2 c1 02               cmpps \\$0x02, %xmm1, %xmm0`],
+     ['f64x2.eq', `66 0f c2 c1 00            cmppd \\$0x00, %xmm1, %xmm0`],
+     ['f64x2.ne', `66 0f c2 c1 04            cmppd \\$0x04, %xmm1, %xmm0`],
+     ['f64x2.lt', `66 0f c2 c1 01            cmppd \\$0x01, %xmm1, %xmm0`],
+     ['f64x2.le', `66 0f c2 c1 02            cmppd \\$0x02, %xmm1, %xmm0`]] );
+
+// Inputs (xmm1, xmm0) because the operation reverses its arguments.
+
+codegenTestX64_v128xv128_v128_reversed(
+    [['i8x16.ge_s', `
+66 0f 64 c1               pcmpgtb %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i16x8.ge_s',
+`
+66 0f 65 c1               pcmpgtw %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i32x4.ge_s', `
+66 0f 66 c1               pcmpgtd %xmm1, %xmm0
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`],
+     ['i8x16.lt_s', `66 0f 64 c1               pcmpgtb %xmm1, %xmm0`],
+     ['i16x8.lt_s', `66 0f 65 c1               pcmpgtw %xmm1, %xmm0`],
+     ['i32x4.lt_s', `66 0f 66 c1               pcmpgtd %xmm1, %xmm0`],
+     ['f32x4.gt', `0f c2 c1 01               cmpps \\$0x01, %xmm1, %xmm0`],
+     ['f32x4.ge', `0f c2 c1 02               cmpps \\$0x02, %xmm1, %xmm0`],
+     ['f64x2.gt', `66 0f c2 c1 01            cmppd \\$0x01, %xmm1, %xmm0`],
+     ['f64x2.ge', `66 0f c2 c1 02            cmppd \\$0x02, %xmm1, %xmm0`]] );
diff --git a/js/src/jit-test/tests/wasm/simd/const-arm64-vixl-codegen.js b/js/src/jit-test/tests/wasm/simd/const-arm64-vixl-codegen.js
new file mode 100644
index 0000000000..9dc08c6e6b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/const-arm64-vixl-codegen.js
@@ -0,0 +1,109 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "baseline" || !getBuildConfiguration().arm64
+
+// Test that the vixl logic for v128 constant loads is at least somewhat
+// reasonable.
+
+var lead = `0x[0-9a-f]+ +[0-9a-f]{8} +`;
+
+var prefix = `${lead}sub     sp, sp, #0x.. \\(..\\)
+${lead}str     x23, \\[sp, #..\\]`;
+
+var suffix =
+`${lead}b       #\\+0x8 \\(addr 0x.*\\)
+${lead}brk     #0x0`;
+
+for ( let [bits, expected, values] of [
+    // If high == low and the byte is 0 or ff then a single movi is sufficient.
+    ['i8x16 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00', `
+${prefix}
+${lead}movi    v0\\.2d, #0x0
+${suffix}
+`,
+     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
+
+    ['i8x16 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0', `
+${prefix}
+${lead}movi    v0\\.2d, #0xff00ff00ff00ff
+${suffix}
+`,
+     [-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0]],
+
+    // Splattable small things (up to a byte, at a byte location)
+    // can also use just one instruction
+    ['i32x4 1 1 1 1', `
+${prefix}
+${lead}movi    v0\\.4s, #0x1, lsl #0
+${suffix}
+`,
+     [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]],
+
+    ['i32x4 0x300 0x300 0x300 0x300', `
+${prefix}
+${lead}movi    v0\\.4s, #0x3, lsl #8
+${suffix}
+`,
+     [0, 3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0]],
+
+    // If high == low but the value is more complex then a constant load
+    // plus a dup is sufficient.  x16 is the designated temp.
+    ['i32x4 1 2 1 2', `
+${prefix}
+${lead}mov     x16, #0x1
+${lead}movk    x16, #0x2, lsl #32
+${lead}dup     v0\\.2d, x16
+${suffix}
+`,
+     [1, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0]],
+
+    // If high != low then we degenerate to a more complicated pattern: dup the low value
+    // and then overwrite the high part with the high value.
+    ['i32x4 1 2 2 1', `
+${prefix}
+${lead}mov     x16, #0x1
+${lead}movk    x16, #0x2, lsl #32
+${lead}dup     v0\\.2d, x16
+${lead}mov     x16, #0x2
+${lead}movk    x16, #0x1, lsl #32
+${lead}mov     v0\\.d\\[1\\], x16
+${suffix}
+`,
+     [1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0]],
+
+    // Things are not always bleak, and vixl finds a way.
+    ['i32x4 1 1 2 2', `
+${prefix}
+${lead}movi    v0\\.4s, #0x1, lsl #0
+${lead}mov     x16, #0x200000002
+${lead}mov     v0\\.d\\[1\\], x16
+${suffix}
+`,
+     [1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0]],
+] ) {
+    let ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1)
+    (func (export "run")
+       (v128.store (i32.const 0) (call $f)))
+    (func $f (export "f") (result v128)
+      (v128.const ${bits})))`);
+    let output = wasmDis(ins.exports.f, {tier:"baseline", asString:true});
+    assertEq(output.match(new RegExp(expected)) != null, true);
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 0, iota(16).map(x => -1-x));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), values);
+}
+
+function get(arr, loc, len) {
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        res.push(arr[loc+i]);
+    }
+    return res;
+}
+
+function set(arr, loc, vals) {
+    for ( let i=0; i < vals.length; i++ ) {
+        arr[loc+i] = vals[i];
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/simd/const-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/const-x64-ion-codegen.js
new file mode 100644
index 0000000000..04a00b538d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/const-x64-ion-codegen.js
@@ -0,0 +1,28 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// Test that constants that can be synthesized are synthesized.  See README-codegen.md
+// for general information about this type of test case.
+
+codegenTestX64_unit_v128(
+    [['v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0',
+      `66 0f ef c0               pxor %xmm0, %xmm0`],
+     ['v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1',
+      `66 0f 75 c0               pcmpeqw %xmm0, %xmm0`],
+     ['v128.const i16x8 0 0 0 0 0 0 0 0',
+      `66 0f ef c0               pxor %xmm0, %xmm0`],
+     ['v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1',
+      `66 0f 75 c0               pcmpeqw %xmm0, %xmm0`],
+     ['v128.const i32x4 0 0 0 0',
+      `66 0f ef c0               pxor %xmm0, %xmm0`],
+     ['v128.const i32x4 -1 -1 -1 -1',
+      `66 0f 75 c0               pcmpeqw %xmm0, %xmm0`],
+     ['v128.const i64x2 0 0',
+      `66 0f ef c0               pxor %xmm0, %xmm0`],
+     ['v128.const i64x2 -1 -1',
+      `66 0f 75 c0               pcmpeqw %xmm0, %xmm0`],
+     ['v128.const f32x4 0 0 0 0',
+      // Arguably this should be xorps but that's for later
+      `66 0f ef c0               pxor %xmm0, %xmm0`],
+     ['v128.const f64x2 0 0',
+      // Arguably this should be xorpd but that's for later
+      `66 0f ef c0               pxor %xmm0, %xmm0`]] );
diff --git a/js/src/jit-test/tests/wasm/simd/cvt-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/cvt-x64-ion-codegen.js
new file mode 100644
index 0000000000..1e2d613c1a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/cvt-x64-ion-codegen.js
@@ -0,0 +1,27 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x64-test.js
+
+// Test that there are no extraneous moves for various SIMD conversion
+// operations. See README-codegen.md for general information about this type of
+// test case.
+
+// Note, these tests test the beginning of the output but not the end.
+
+codegenTestX64_v128_v128(
+    [['i32x4.trunc_sat_f32x4_s',
+     // The movaps is dest -> scratch and needs to be here.  The test is
+     // asserting that there is not an additional (redundant) move here.
+`
+44 0f 28 f8               movaps %xmm0, %xmm15
+45 0f c2 ff 00            cmpps \\$0x00, %xmm15, %xmm15
+66 41 0f db c7            pand %xmm15, %xmm0`],
+     ['i32x4.trunc_sat_f32x4_u', `
+45 0f 57 ff               xorps %xmm15, %xmm15
+41 0f 5f c7               maxps %xmm15, %xmm0`],
+     ['f32x4.convert_i32x4_u', `
+66 45 0f ef ff            pxor %xmm15, %xmm15
+66 44 0f 3a 0e f8 55      pblendw \\$0x55, %xmm0, %xmm15
+66 41 0f fa c7            psubd %xmm15, %xmm0
+45 0f 5b ff               cvtdq2ps %xmm15, %xmm15`]],
+    {no_suffix:true});
+
+
diff --git a/js/src/jit-test/tests/wasm/simd/debug-bug1644759.js b/js/src/jit-test/tests/wasm/simd/debug-bug1644759.js
new file mode 100644
index 0000000000..0de46e0f0c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/debug-bug1644759.js
@@ -0,0 +1,20 @@
+// |jit-test| skip-if: !wasmDebuggingEnabled() || !wasmSimdEnabled()
+
+var g7 = newGlobal({newCompartment: true});
+g7.parent = this;
+g7.eval(`
+    Debugger(parent).onEnterFrame = function(frame) { };
+`);
+var ins = wasmEvalText(`
+    (memory (export "mem") 1 1)
+    (func (export "run")
+      (param $k i32)
+      (v128.store (i32.const 0) (call $f (local.get $k)))
+    )
+    (func $f
+      (param $k i32)
+      (result v128)
+      (v128.const i32x4 5 6 7 8)
+    )
+`);
+ins.exports.run(0);
diff --git a/js/src/jit-test/tests/wasm/simd/directives.txt b/js/src/jit-test/tests/wasm/simd/directives.txt
new file mode 100644
index 0000000000..3e89e7550b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=baseline; test-also=--wasm-compiler=optimizing; test-also=--wasm-test-serialization; test-also=--wasm-compiler=optimizing --no-avx; skip-variant-if: --wasm-compiler=optimizing --no-avx, !getBuildConfiguration().x86 && !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:wasm.js
diff --git a/js/src/jit-test/tests/wasm/simd/disabled.js b/js/src/jit-test/tests/wasm/simd/disabled.js
new file mode 100644
index 0000000000..feae414697
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/disabled.js
@@ -0,0 +1,28 @@
+// |jit-test| skip-if: wasmSimdEnabled()
+
+// ../binary.js checks that all SIMD extended opcodes in the 0..255 range are
+// rejected if !wasmSimdEnabled, so no need to check that here.
+
+// Non-opcode cases that should also be rejected, lest feature sniffing may
+// erroneously conclude that simd is available when it's not.  The error message
+// may differ depending on ENABLE_WASM_SIMD: if SIMD is compiled in we usually
+// get a sensible error about v128; if not, we get something generic.
+
+wasmFailValidateText(`(module (func (param v128)))`,
+                     /(v128 not enabled)|(bad type)/);
+
+wasmFailValidateText(`(module (func (result v128)))`,
+                     /(v128 not enabled)|(bad type)/);
+
+wasmFailValidateText(`(module (func (local v128)))`,
+                     /(v128 not enabled)|(bad type)|(SIMD support is not enabled)/);
+
+wasmFailValidateText(`(module (global (import "m" "g") v128))`,
+                     /expected global type/);
+
+wasmFailValidateText(`(module (global (import "m" "g") (mut v128)))`,
+                     /expected global type/);
+
+wasmFailValidateText(`(module (global i32 (v128.const i32x4 0 0 0 0)))`,
+                     /(v128 not enabled)|(unrecognized opcode)/);
+
diff --git a/js/src/jit-test/tests/wasm/simd/experimental.js b/js/src/jit-test/tests/wasm/simd/experimental.js
new file mode 100644
index 0000000000..3f4a85ae75
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/experimental.js
@@ -0,0 +1,411 @@
+// |jit-test| --wasm-relaxed-simd; skip-if: !wasmRelaxedSimdEnabled()
+
+// Experimental opcodes.  We have no text parsing support for these yet.  The
+// tests will be cleaned up and moved into ad-hack.js if the opcodes are
+// adopted.
+
+load(libdir + "wasm-binary.js");
+
+function wasmEval(bytes, imports) {
+    return new WebAssembly.Instance(new WebAssembly.Module(bytes), imports);
+}
+
+function wasmValidateAndEval(bytes, imports) {
+    assertEq(WebAssembly.validate(bytes), true, "test of WasmValidate.cpp");
+    return wasmEval(bytes, imports);
+}
+
+function get(arr, loc, len) {
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        res.push(arr[loc+i]);
+    }
+    return res;
+}
+
+function set(arr, loc, vals) {
+    for ( let i=0; i < vals.length; i++ ) {
+        if (arr instanceof BigInt64Array) {
+            arr[loc+i] = BigInt(vals[i]);
+        } else {
+            arr[loc+i] = vals[i];
+        }
+    }
+}
+
+const v2vSig = {args:[], ret:VoidCode};
+
+function V128Load(addr) {
+    return [I32ConstCode, varS32(addr),
+            SimdPrefix, V128LoadCode, 4, varU32(0)]
+}
+
+function V128StoreExpr(addr, v) {
+    return [I32ConstCode, varS32(addr),
+            ...v,
+            SimdPrefix, V128StoreCode, 4, varU32(0)];
+}
+
+// FMA/FNMA, https://github.com/WebAssembly/relaxed-simd/issues/27 and
+// https://github.com/WebAssembly/relaxed-simd/pull/81
+
+function fma(x, y, a) { return (x * y) + a; }
+function fnma(x, y, a) { return - (x * y) + a; }
+
+var fxs = [10, 20, 30, 40];
+var fys = [-2, -3, -4, -5];
+var fas = [0, 100, 500, 700];
+var dxs = [10, 20];
+var dys = [-2, -3];
+var das = [0, 100];
+
+for ( let [opcode, xs, ys, as, operator] of [[F32x4RelaxedFmaCode, fxs, fys, fas, fma],
+                                             [F32x4RelaxedFnmaCode, fxs, fys, fas, fnma],
+                                             [F64x2RelaxedFmaCode, dxs, dys, das, fma],
+                                             [F64x2RelaxedFnmaCode, dxs, dys, das, fnma]] ) {
+    var k = xs.length;
+    var ans = iota(k).map((i) => operator(xs[i], ys[i], as[i]))
+
+    var ins = wasmValidateAndEval(moduleWithSections([
+        sigSection([v2vSig]),
+        declSection([0]),
+        memorySection(1),
+        exportSection([{funcIndex: 0, name: "run"},
+                       {memIndex: 0, name: "mem"}]),
+        bodySection([
+            funcBody({locals:[],
+                      body: [...V128StoreExpr(0, [...V128Load(16),
+                                                  ...V128Load(32),
+                                                  ...V128Load(48),
+                                                  SimdPrefix, varU32(opcode)])]})])]));
+
+    var mem = new (k == 4 ? Float32Array : Float64Array)(ins.exports.mem.buffer);
+    set(mem, k, xs);
+    set(mem, 2*k, ys);
+    set(mem, 3*k, as);
+    ins.exports.run();
+    var result = get(mem, 0, k);
+    assertSame(result, ans);
+
+    assertEq(false, WebAssembly.validate(moduleWithSections([
+        sigSection([v2vSig]),
+        declSection([0]),
+        memorySection(1),
+        exportSection([{funcIndex: 0, name: "run"},
+                       {memIndex: 0, name: "mem"}]),
+        bodySection([
+            funcBody({locals:[],
+                      body: [...V128StoreExpr(0, [...V128Load(0),
+                                                  ...V128Load(0),
+                                                  SimdPrefix, varU32(opcode)])]})])])));    
+}
+
+// Relaxed swizzle, https://github.com/WebAssembly/relaxed-simd/issues/22
+
+var ins = wasmValidateAndEval(moduleWithSections([
+    sigSection([v2vSig]),
+    declSection([0]),
+    memorySection(1),
+    exportSection([{funcIndex: 0, name: "run"},
+                   {memIndex: 0, name: "mem"}]),
+    bodySection([
+        funcBody({locals:[],
+                  body: [...V128StoreExpr(0, [...V128Load(16),
+                                              ...V128Load(32),
+                                              SimdPrefix, varU32(I8x16RelaxedSwizzleCode)])]})])]));
+var mem = new Uint8Array(ins.exports.mem.buffer);
+var test = [1, 4, 3, 7, 123, 0, 8, 222];
+set(mem, 16, test);
+for (let [i, s] of [[0, 0], [0, 1], [1,1], [1, 3], [7,5]]) {
+    var ans = new Uint8Array(16);
+    for (let j = 0; j < 16; j++) {
+        mem[32 + j] = (j * s + i) & 15;
+        ans[j] = test[(j * s + i) & 15];
+    }
+    ins.exports.run();
+    var result = get(mem, 0, 16);
+    assertSame(result, ans);
+}
+
+assertEq(false, WebAssembly.validate(moduleWithSections([
+    sigSection([v2vSig]),
+    declSection([0]),
+    memorySection(1),
+    bodySection([
+        funcBody({locals:[],
+            body: [...V128StoreExpr(0, [...V128Load(16),
+                                        SimdPrefix, varU32(I8x16RelaxedSwizzleCode)])]})])])));
+
+
+// Relaxed MIN/MAX, https://github.com/WebAssembly/relaxed-simd/issues/33
+
+const Neg0 = -1/Infinity;
+var minMaxTests = [
+    {a: 0, b: 0, min: 0, max: 0, },
+    {a: Neg0, b: Neg0, min: Neg0, max: Neg0, },
+    {a: 1/3, b: 2/3, min: 1/3, max: 2/3, },
+    {a: -1/3, b: -2/3, min: -2/3, max: -1/3, },
+    {a: -1000, b: 1, min: -1000, max: 1, },
+    {a: 10, b: -2, min: -2, max: 10, },
+];
+
+for (let k of [4, 2]) {
+    const minOpcode = k == 4 ? F32x4RelaxedMinCode : F64x2RelaxedMinCode;
+    const maxOpcode = k == 4 ? F32x4RelaxedMaxCode : F64x2RelaxedMaxCode;
+
+    var ins = wasmValidateAndEval(moduleWithSections([
+        sigSection([v2vSig]),
+        declSection([0, 0]),
+        memorySection(1),
+        exportSection([{funcIndex: 0, name: "min"},
+                       {funcIndex: 1, name: "max"},
+                       {memIndex: 0, name: "mem"}]),
+        bodySection([
+            funcBody({locals:[],
+                      body: [...V128StoreExpr(0, [...V128Load(16),
+                                                  ...V128Load(32),
+                                                  SimdPrefix, varU32(minOpcode)])]}),
+            funcBody({locals:[],
+                      body: [...V128StoreExpr(0, [...V128Load(16),
+                                                  ...V128Load(32),
+                                                  SimdPrefix, varU32(maxOpcode)])]})])]));
+    for (let i = 0; i < minMaxTests.length; i++) {
+        var Ty = k == 4 ? Float32Array : Float64Array;
+        var mem = new Ty(ins.exports.mem.buffer);
+        var minResult = new Ty(k);
+        var maxResult = new Ty(k);
+        for (let j = 0; j < k; j++) {
+            const {a, b, min, max } = minMaxTests[(j + i) % minMaxTests.length];
+            mem[j + k] = a;
+            mem[j + k * 2] = b;
+            minResult[j] = min;
+            maxResult[j] = max;
+        }
+        ins.exports.min();
+        var result = get(mem, 0, k);
+        assertSame(result, minResult);
+        ins.exports.max();
+        var result = get(mem, 0, k);
+        assertSame(result, maxResult);
+    }
+
+    for (let op of [minOpcode, maxOpcode]) {
+        assertEq(false, WebAssembly.validate(moduleWithSections([
+            sigSection([v2vSig]),
+            declSection([0, 0]),
+            memorySection(1),
+            exportSection([]),
+            bodySection([
+                funcBody({locals:[],
+                          body: [...V128StoreExpr(0, [...V128Load(0),
+                                                      SimdPrefix, varU32(op)])]})])])));
+    }
+}
+
+// Relaxed I32x4.TruncFXXX, https://github.com/WebAssembly/relaxed-simd/issues/21
+
+var ins = wasmValidateAndEval(moduleWithSections([
+    sigSection([v2vSig]),
+    declSection([0, 0, 0, 0]),
+    memorySection(1),
+    exportSection([{funcIndex: 0, name: "from32s"},
+                   {funcIndex: 1, name: "from32u"},
+                   {funcIndex: 2, name: "from64s"},
+                   {funcIndex: 3, name: "from64u"},
+                   {memIndex: 0, name: "mem"}]),
+    bodySection([
+        funcBody({locals:[],
+                  body: [...V128StoreExpr(0, [...V128Load(16),
+                                              SimdPrefix, varU32(I32x4RelaxedTruncSSatF32x4Code)])]}),
+        funcBody({locals:[],
+                  body: [...V128StoreExpr(0, [...V128Load(16),
+                                              SimdPrefix, varU32(I32x4RelaxedTruncUSatF32x4Code)])]}),
+        funcBody({locals:[],
+                  body: [...V128StoreExpr(0, [...V128Load(16),
+                                              SimdPrefix, varU32(I32x4RelaxedTruncSatF64x2SZeroCode)])]}),
+        funcBody({locals:[],
+                  body: [...V128StoreExpr(0, [...V128Load(16),
+                                              SimdPrefix, varU32(I32x4RelaxedTruncSatF64x2UZeroCode)])]})])]));
+
+var mem = ins.exports.mem.buffer;
+set(new Float32Array(mem), 4, [0, 2.3, -3.4, 100000]);
+ins.exports.from32s();
+var result = get(new Int32Array(mem), 0, 4);
+assertSame(result, [0, 2, -3, 100000]);
+
+set(new Float32Array(mem), 4, [0, 3.3, 0x80000000, 200000]);
+ins.exports.from32u();
+var result = get(new Uint32Array(mem), 0, 4);
+assertSame(result, [0, 3, 0x80000000, 200000]);
+set(new Float32Array(mem), 4, [0, 0x80000100, 0x80000101, 0xFFFFFF00]);
+ins.exports.from32u();
+var result = get(new Uint32Array(mem), 0, 4);
+assertSame(result, [0, 0x80000100, 0x80000100, 0xFFFFFF00]);
+
+set(new Float64Array(mem), 2, [200000.3, -3.4]);
+ins.exports.from64s();
+var result = get(new Int32Array(mem), 0, 4);
+assertSame(result, [200000, -3, 0, 0]);
+set(new Float64Array(mem), 2, [0x90000000 + 0.1, 0]);
+ins.exports.from64u();
+var result = get(new Uint32Array(mem), 0, 4);
+assertSame(result, [0x90000000, 0, 0, 0]);
+
+for (let op of [I32x4RelaxedTruncSSatF32x4Code, I32x4RelaxedTruncUSatF32x4Code,
+                I32x4RelaxedTruncSatF64x2SZeroCode, I32x4RelaxedTruncSatF64x2UZeroCode]) {
+    assertEq(false, WebAssembly.validate(moduleWithSections([
+        sigSection([v2vSig]),
+        declSection([0]),
+        memorySection(1),
+        exportSection([]),
+        bodySection([
+            funcBody({locals:[],
+                      body: [...V128StoreExpr(0, [SimdPrefix, varU32(op)])]})])])));
+}
+
+// Relaxed blend / laneselect, https://github.com/WebAssembly/relaxed-simd/issues/17
+
+for (let [k, opcode, AT] of [[1, I8x16RelaxedLaneSelectCode, Int8Array],
+                             [2, I16x8RelaxedLaneSelectCode, Int16Array],
+                             [4, I32x4RelaxedLaneSelectCode, Int32Array],
+                             [8, I64x2RelaxedLaneSelectCode, BigInt64Array]]) {
+
+    var ins = wasmValidateAndEval(moduleWithSections([
+        sigSection([v2vSig]),
+        declSection([0]),
+        memorySection(1),
+        exportSection([{funcIndex: 0, name: "run"},
+                        {memIndex: 0, name: "mem"}]),
+        bodySection([
+            funcBody({locals:[],
+                        body: [...V128StoreExpr(0, [...V128Load(16),
+                                                    ...V128Load(32),
+                                                    ...V128Load(48),
+                                                    SimdPrefix, varU32(opcode)])]})])]));
+
+    var mem = ins.exports.mem.buffer;
+    var mem8 = new Uint8Array(mem);
+    set(mem8, 16, [1,2,3,4,0,0,0,0,100,0,102,0,0,250,251,252,253]);
+    set(mem8, 32, [0,0,0,0,5,6,7,8,0,101,0,103,0,254,255,0,1]);
+    var c = new AT(mem, 48, 16 / k);
+    for (let i = 0; i < c.length; i++) {
+        // Use popcnt to randomize 0 and ~0 
+        const popcnt_i = i.toString(2).replace(/0/g, "").length;
+        const v = popcnt_i & 1 ? -1 : 0
+        c[i] = k == 8 ? BigInt(v) : v;
+    }
+    ins.exports.run();
+    for (let i = 0; i < 16; i++) {
+        const r = c[(i / k) | 0] ? mem8[16 + i] : mem8[32 + i];
+        assertEq(r, mem8[i]);
+    }
+
+    assertEq(false, WebAssembly.validate(moduleWithSections([
+        sigSection([v2vSig]),
+        declSection([0]),
+        memorySection(1),
+        exportSection([{funcIndex: 0, name: "run"},
+                       {memIndex: 0, name: "mem"}]),
+        bodySection([
+            funcBody({locals:[],
+                      body: [...V128StoreExpr(0, [...V128Load(0),
+                                                  ...V128Load(0),
+                                                  SimdPrefix, varU32(opcode)])]})])])));    
+}
+
+
+// Relaxed rounding q-format multiplication.
+var ins = wasmValidateAndEval(moduleWithSections([
+    sigSection([v2vSig]),
+    declSection([0]),
+    memorySection(1),
+    exportSection([{funcIndex: 0, name: "relaxed_q15mulr_s"},
+                    {memIndex: 0, name: "mem"}]),
+    bodySection([
+        funcBody({locals:[],
+                    body: [...V128StoreExpr(0, [...V128Load(16),
+                                                ...V128Load(32),
+                                                SimdPrefix, varU32(I16x8RelaxedQ15MulrS)])]})])]));
+
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+for (let [as, bs] of cross([
+        [1, -3, 5, -7, 11, -13, -17, 19],
+        [-1, 0, 16, -32, 64, 128, -1024, 0, 1],
+        [1,2,-32768,32767,1,4,-32768,32767]]) ) {
+    set(mem16, 8, as);
+    set(mem16, 16, bs);
+    ins.exports.relaxed_q15mulr_s();
+    const result = get(mem16, 0, 8);
+    for (let i = 0; i < 8; i++) {
+        const expected = (as[i] * bs[i] + 0x4000) >> 15;
+        if (as[i] == -32768 && bs[i] == -32768) continue;
+        assertEq(expected, result[i], `result of ${as[i]} * ${bs[i]}`);
+    }
+}
+
+
+// Check relaxed dot product results.
+var ins = wasmValidateAndEval(moduleWithSections([
+    sigSection([v2vSig]),
+    declSection([0]),
+    memorySection(1),
+    exportSection([{funcIndex: 0, name: "dot_i8x16_i7x16_s"},
+                    {memIndex: 0, name: "mem"}]),
+    bodySection([
+        funcBody({locals:[],
+                    body: [...V128StoreExpr(0, [...V128Load(16),
+                                                ...V128Load(32),
+                                                SimdPrefix, varU32(I16x8DotI8x16I7x16S)])]})])]));
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+var mem16 = new Int16Array(ins.exports.mem.buffer);
+var test7bit = [1, 2, 3, 4, 5, 64, 65, 127, 127, 0, 0,
+                1, 65, 64, 2, 3, 0, 0, 127, 127, 5, 4];
+var testNeg = test7bit.concat(test7bit.map(i => ~i));
+for (let ai = 0; ai < testNeg.length - 15; ai++)
+    for (let bi = 0; bi < test7bit.length - 15; bi++) {
+        set(mem8, 16, testNeg.slice(ai, ai + 16));
+        set(mem8, 32, test7bit.slice(bi, bi + 16));
+        ins.exports.dot_i8x16_i7x16_s();
+        const result = get(mem16, 0, 8);
+        for (let i = 0; i < 8; i++) {
+            const expected = ((testNeg[ai + i * 2] * test7bit[bi + i * 2]) +
+                            (testNeg[ai + i * 2 + 1] * test7bit[bi + i * 2 + 1])) | 0;
+            assertEq(expected, result[i]);
+        }
+    }
+
+var ins = wasmValidateAndEval(moduleWithSections([
+    sigSection([v2vSig]),
+    declSection([0]),
+    memorySection(1),
+    exportSection([{funcIndex: 0, name: "dot_i8x16_i7x16_add_s"},
+                    {memIndex: 0, name: "mem"}]),
+    bodySection([
+        funcBody({locals:[],
+                    body: [...V128StoreExpr(0, [...V128Load(16),
+                                                ...V128Load(32),
+                                                ...V128Load(48),
+                                                SimdPrefix, varU32(I32x4DotI8x16I7x16AddS)])]})])]));
+var mem8 = new Int8Array(ins.exports.mem.buffer);
+var mem32 = new Int32Array(ins.exports.mem.buffer);
+var test7bit = [1, 2, 3, 4, 5, 64, 65, 127, 127, 0, 0,
+                1, 65, 64, 2, 3, 0, 0, 127, 127, 5, 4];
+var testNeg = test7bit.concat(test7bit.map(i => ~i));
+var testAcc = [0, 12, 65336, -1, 0x10000000, -0xffffff];
+for (let ai = 0; ai < testNeg.length - 15; ai++)
+    for (let bi = 0; bi < test7bit.length - 15; bi++)
+        for (let ci = 0; ci < testAcc.length - 3; ci++) {
+            set(mem8, 16, testNeg.slice(ai, ai + 16));
+            set(mem8, 32, test7bit.slice(bi, bi + 16));
+            set(mem32, 48/4, testAcc.slice(ci, ci + 4));
+            ins.exports.dot_i8x16_i7x16_add_s();
+            const result = get(mem32, 0, 4);
+            for (let i = 0; i < 4; i++) {
+                const a1 = (testNeg[ai + i * 4] * test7bit[bi + i * 4]) +
+                           (testNeg[ai + i * 4 + 1] * test7bit[bi + i * 4 + 1]);
+                const a2 = (testNeg[ai + i * 4 + 2] * test7bit[bi + i * 4 + 2]) +
+                           (testNeg[ai + i * 4 + 3] * test7bit[bi + i * 4 + 3]);
+                const expected = (testAcc[ci + i] + a1 + a2) | 0;
+                assertEq(expected, result[i]);
+            }
+        }
diff --git a/js/src/jit-test/tests/wasm/simd/ion-analysis.js b/js/src/jit-test/tests/wasm/simd/ion-analysis.js
new file mode 100644
index 0000000000..723b42b40b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ion-analysis.js
@@ -0,0 +1,902 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || wasmCompileMode() != "ion" || !this.wasmSimdAnalysis
+
+// White-box tests for SIMD optimizations.  These are sensitive to internal
+// details of the front-end and lowering logic, which is partly platform-dependent.
+//
+// In DEBUG builds, the testing function wasmSimdAnalysis() returns a string
+// describing the last decision made by the SIMD lowering code: to perform an
+// optimized lowering or the default byte shuffle+blend for i8x16.shuffle; to
+// shift by a constant or a variable for the various shifts; and so on.
+//
+// We test that the expected transformation applies, and that the machine code
+// generates the expected result.
+
+var isArm64 = getBuildConfiguration().arm64;
+
+// 32-bit permutation that is not a rotation.
+let perm32x4_pattern = [4, 5, 6, 7, 12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3];
+
+// Operands the same, dword permutation
+{
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${perm32x4_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm32x4_pattern);
+}
+
+// Right operand ignored, dword permutation
+{
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${perm32x4_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    set(mem, 32, iota(16).map(x => x+16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm32x4_pattern);
+}
+
+// Left operand ignored, dword permutation
+{
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${perm32x4_pattern.map(x => x+16).join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16).map(x => x+16));
+    set(mem, 32, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm32x4_pattern);
+}
+
+// Operands the same, word permutation on both sides of the qword divide, with a qword swap
+{
+    let perm16x8_pattern = [12, 13, 14, 15, 10, 11, 8, 9,
+                             6,  7,  4,  5,  2,  3, 0, 1];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${perm16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm16x8_pattern);
+}
+
+// Operands the same, word permutation on both sides of the qword divide, no qword swap
+{
+    let perm16x8_pattern = [ 6,  7,  4,  5,  2,  3, 0, 1,
+                            12, 13, 14, 15, 10, 11, 8, 9];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${perm16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm16x8_pattern);
+}
+
+// Operands the same, word permutation on low side of the qword divide, no qword swap
+{
+    let perm16x8_pattern = [ 6, 7,  4,  5,  2,  3,  0,  1,
+                             8, 9, 10, 11, 12, 13, 14, 15];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${perm16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm16x8_pattern);
+}
+
+// Operands the same, word permutation on high side of the qword divide, no qword swap
+{
+    let perm16x8_pattern = [ 0,  1,  2,  3,  4,  5, 6, 7,
+                            12, 13, 14, 15, 10, 11, 8, 9];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${perm16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm16x8_pattern);
+}
+
+// Same operands, byte rotate
+{
+    // 8-bit permutation that is a rotation
+    let rot8x16_pattern = [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${rot8x16_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> rotate-right 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), rot8x16_pattern);
+}
+
+// Operands the same, random jumble => byte permutation
+{
+    // 8-bit permutation that is not a rotation
+    let perm8x16_pattern = [5, 7, 6, 8, 9, 10, 11, 4, 13, 14, 15, 0, 1, 2, 3, 12];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${perm8x16_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), perm8x16_pattern);
+}
+
+// Operands differ, both accessed, rhs is constant zero, left-shift pattern
+{
+    // 8-bit shift with zeroes shifted in at the right end
+    let shift8x16_pattern = [16, 16, 16, 16, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${shift8x16_pattern.join(' ')} (local.get 0) (v128.const i32x4 0 0 0 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> shift-left 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), shift8x16_pattern.map(x => x >= 16 ? 0 : x));
+}
+
+// The same as above but the constant is lhs.
+{
+    // 8-bit shift with zeroes shifted in at the right end
+    let shift8x16_pattern = [16, 16, 16, 16, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => x ^ 16);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${shift8x16_pattern.join(' ')} (v128.const i32x4 0 0 0 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> shift-left 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), shift8x16_pattern.map(x => x < 16 ? 0 : x - 16));
+}
+
+// Operands differ, both accessed, rhs is constant zero, left-shift pattern that
+// does not start properly.
+{
+    // 8-bit shift with zeroes shifted in at the right end
+    let shift8x16_pattern = [16, 16, 16, 16, 16, 16, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${shift8x16_pattern.join(' ')} (local.get 0) (v128.const i32x4 0 0 0 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> shuffle+blend 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), shift8x16_pattern.map(x => x >= 16 ? 0 : x));
+}
+
+// Operands differ, both accessed, rhs is constant zero, right-shift pattern
+{
+    // 8-bit shift with zeroes shifted in at the right end
+    let shift8x16_pattern = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 20, 20, 20, 20, 20, 20];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${shift8x16_pattern.join(' ')} (local.get 0) (v128.const i32x4 0 0 0 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> shift-right 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), shift8x16_pattern.map(x => x >= 16 ? 0 : x));
+}
+
+// Operands differ, both accessed, rhs is constant zero, right-shift pattern
+// that does not end properly.
+{
+    // 8-bit shift with zeroes shifted in at the right end
+    let shift8x16_pattern = [6, 7, 8, 9, 10, 11, 12, 13, 14, 20, 20, 20, 20, 20, 20, 20];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${shift8x16_pattern.join(' ')} (local.get 0) (v128.const i32x4 0 0 0 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> shuffle+blend 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), shift8x16_pattern.map(x => x >= 16 ? 0 : x));
+}
+
+// Operands differ and are variable, both accessed, (lhs ++ rhs) >> k
+{
+    let concat8x16_pattern = [27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${concat8x16_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> concat+shift-right 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    set(mem, 32, iota(16).map(k => k+16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), concat8x16_pattern);
+}
+
+// Operands differ and are variable, both accessed, (rhs ++ lhs) >> k
+{
+    let concat8x16_pattern = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${concat8x16_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> concat+shift-right 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    set(mem, 32, iota(16).map(k => k+16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), concat8x16_pattern);
+}
+
+// Operands differ, both accessed, but inputs stay in their lanes => byte blend
+{
+    let blend8x16_pattern = iota(16).map(x => (x % 3 == 0) ? x + 16 : x);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${blend8x16_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> blend 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    let lhs = iota(16);
+    let rhs = iota(16).map(x => x+16);
+    set(mem, 16, lhs);
+    set(mem, 32, rhs);
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), blend8x16_pattern);
+}
+
+// Operands differ, both accessed, but inputs stay in their lanes => word blend
+{
+    let blend16x8_pattern = iota(16).map(x => (x & 2) ? x + 16 : x);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${blend16x8_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> blend 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    let lhs = iota(16);
+    let rhs = iota(16).map(x => x+16);
+    set(mem, 16, lhs);
+    set(mem, 32, rhs);
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), blend16x8_pattern);
+}
+
+// Interleave i32x4s
+for ( let [lhs, rhs, expected] of
+      [[[0, 1], [4, 5], "shuffle -> interleave-low 32x4"],
+       [[2, 3], [6, 7], "shuffle -> interleave-high 32x4"]] ) {
+    for (let swap of [false, true]) {
+        if (swap)
+            [lhs, rhs] = [rhs, lhs];
+        let interleave_pattern = i32ToI8(interleave(lhs, rhs));
+        let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${interleave_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+        assertEq(wasmSimdAnalysis(), expected);
+
+        let mem = new Int8Array(ins.exports.mem.buffer);
+        let lhsval = iota(16);
+        let rhsval = iota(16).map(x => x+16);
+        set(mem, 16, lhsval);
+        set(mem, 32, rhsval);
+        ins.exports.run();
+        assertSame(get(mem, 0, 16), interleave_pattern);
+    }
+}
+
+// Interleave i64x2s
+for ( let [lhs, rhs, expected] of
+  [[[0], [2], "shuffle -> interleave-low 64x2"],
+   [[1], [3], "shuffle -> interleave-high 64x2"]] ) {
+    for (let swap of [false, true]) {
+        if (swap)
+            [lhs, rhs] = [rhs, lhs];
+        let interleave_pattern = i64ToI2(interleave(lhs, rhs));
+        let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${interleave_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+        assertEq(wasmSimdAnalysis(), expected);
+
+        let mem = new Int8Array(ins.exports.mem.buffer);
+        let lhsval = iota(16);
+        let rhsval = iota(16).map(x => x+16);
+        set(mem, 16, lhsval);
+        set(mem, 32, rhsval);
+        ins.exports.run();
+        assertSame(get(mem, 0, 16), interleave_pattern);
+    }
+}
+
+// Interleave i16x8s
+for ( let [lhs, rhs, expected] of
+      [[[0, 1, 2, 3], [8, 9, 10, 11], "shuffle -> interleave-low 16x8"],
+       [[4, 5, 6, 7], [12, 13, 14, 15], "shuffle -> interleave-high 16x8"]] ) {
+    for (let swap of [false, true]) {
+        if (swap)
+            [lhs, rhs] = [rhs, lhs];
+        let interleave_pattern = i16ToI8(interleave(lhs, rhs));
+        let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${interleave_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+        assertEq(wasmSimdAnalysis(), expected);
+
+        let mem = new Int8Array(ins.exports.mem.buffer);
+        let lhsval = iota(16);
+        let rhsval = iota(16).map(x => x+16);
+        set(mem, 16, lhsval);
+        set(mem, 32, rhsval);
+        ins.exports.run();
+        assertSame(get(mem, 0, 16), interleave_pattern);
+    }
+}
+
+// Interleave i8x16s
+for ( let [lhs, rhs, expected] of
+      [[[0, 1, 2, 3, 4, 5, 6, 7],      [16, 17, 18, 19, 20, 21, 22, 23], "shuffle -> interleave-low 8x16"],
+       [[8, 9, 10, 11, 12, 13, 14, 15],[24, 25, 26, 27, 28, 29, 30, 31], "shuffle -> interleave-high 8x16"]] ) {
+    for (let swap of [false, true]) {
+        if (swap)
+            [lhs, rhs] = [rhs, lhs];
+        let interleave_pattern = interleave(lhs, rhs);
+        let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${interleave_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+        assertEq(wasmSimdAnalysis(), expected);
+
+        let mem = new Int8Array(ins.exports.mem.buffer);
+        let lhsval = iota(16);
+        let rhsval = iota(16).map(x => x+16);
+        set(mem, 16, lhsval);
+        set(mem, 32, rhsval);
+        ins.exports.run();
+        assertSame(get(mem, 0, 16), interleave_pattern);
+    }
+}
+
+// Operands differ, both accessed, random jumble => byte shuffle+blend
+{
+    let blend_perm8x16_pattern = [5, 23, 6, 24, 9, 10, 11, 7, 7, 14, 15, 19, 1, 2, 3, 12];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${blend_perm8x16_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> shuffle+blend 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    let lhs = iota(16).map(x => x+16);
+    let rhs = iota(16);
+    set(mem, 16, lhs);
+    set(mem, 32, rhs);
+    ins.exports.run();
+    assertSame(get(mem, 0, 16),
+               blend_perm8x16_pattern.map(x => x < 16 ? lhs[x] : rhs[x-16]));
+}
+
+// No-op, ignoring right operand, should turn into a move.
+{
+    let nop8x16_pattern = iota(16);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${nop8x16_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> move");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    set(mem, 32, iota(16).map(x => x+16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), nop8x16_pattern);
+}
+
+// No-op, ignoring left operand, should turn into a move.
+{
+    let nop8x16_pattern = iota(16).map(x => x+16);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)) (v128.load (i32.const 32)))))
+  (func $f (param v128) (param v128) (result v128)
+    (i8x16.shuffle ${nop8x16_pattern.join(' ')} (local.get 0) (local.get 1))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> move");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    set(mem, 32, iota(16).map(x => x+16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), nop8x16_pattern);
+}
+
+// Broadcast byte
+for ( let byte of [3, 11, 8, 2] ) {
+    let broadcast8x16_pattern = iota(16).map(_ => byte);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${broadcast8x16_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> broadcast 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), broadcast8x16_pattern);
+}
+
+// Broadcast word from high quadword
+{
+    let broadcast16x8_pattern = [10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${broadcast16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> broadcast 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), broadcast16x8_pattern);
+}
+
+// Broadcast word from low quadword
+{
+    let broadcast16x8_pattern = [4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${broadcast16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> broadcast 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), broadcast16x8_pattern);
+}
+
+// Broadcast dword from low quadword should turn into a dword permute
+{
+    let broadcast32x4_pattern = [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7];
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${broadcast32x4_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), broadcast32x4_pattern);
+}
+
+// Broadcast high qword should turn into a dword permute
+{
+    let broadcast64x2_pattern = [8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15]
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${broadcast64x2_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), broadcast64x2_pattern);
+}
+
+// Byte reversal should be a byte permute
+{
+    let rev8x16_pattern = iota(16).reverse();
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${rev8x16_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 8x16");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), rev8x16_pattern);
+}
+
+// Byteswap of half-word, word and quad-word groups should be
+// reverse bytes analysis
+for (let k of [2, 4, 8]) {
+  let rev8_pattern = iota(16).map(i => i ^ (k - 1));
+  let ins = wasmCompile(`
+(module
+(memory (export "mem") 1 1)
+(func (export "run")
+  (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+(func $f (param v128) (result v128)
+  (i8x16.shuffle ${rev8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+  assertEq(wasmSimdAnalysis(), `shuffle -> reverse bytes in ${8 * k}-bit lanes`);
+
+  let mem = new Int8Array(ins.exports.mem.buffer);
+  set(mem, 16, iota(16));
+  ins.exports.run();
+  assertSame(get(mem, 0, 16), rev8_pattern);
+}
+
+// Word reversal should be a word permute
+{
+    let rev16x8_pattern = i16ToI8(iota(8).reverse());
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${rev16x8_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 16x8");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), rev16x8_pattern);
+}
+
+// Dword reversal should be a dword permute
+{
+    let rev32x4_pattern = i32ToI8([3, 2, 1, 0]);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${rev32x4_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), rev32x4_pattern);
+}
+
+// Qword reversal should be a dword permute
+{
+    let rev64x2_pattern = i32ToI8([2, 3, 0, 1]);
+    let ins = wasmCompile(`
+(module
+  (memory (export "mem") 1 1)
+  (func (export "run")
+    (v128.store (i32.const 0) (call $f (v128.load (i32.const 16)))))
+  (func $f (param v128) (result v128)
+    (i8x16.shuffle ${rev64x2_pattern.join(' ')} (local.get 0) (local.get 0))))`);
+
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+
+    let mem = new Int8Array(ins.exports.mem.buffer);
+    set(mem, 16, iota(16));
+    ins.exports.run();
+    assertSame(get(mem, 0, 16), rev64x2_pattern);
+}
+
+// In the case of shifts, we have separate tests that constant shifts work
+// correctly, so no such testing is done here.
+
+for ( let lanes of ['i8x16', 'i16x8', 'i32x4', 'i64x2'] ) {
+    for ( let shift of ['shl', 'shr_s', 'shr_u'] ) {
+        for ( let [count, result] of [['(i32.const 5)', /shift -> constant shift/],
+                                      ['(local.get 1)', /shift -> variable(?: scalarized)? shift/]] ) {
+            wasmCompile(`(module (func (param v128) (param i32) (result v128) (${lanes}.${shift} (local.get 0) ${count})))`);
+            assertEq(wasmSimdAnalysis().match(result).length, 1);
+        }
+    }
+}
+
+// Constant folding scalar->simd.  There are functional tests for all these in
+// ad-hack.js so here we only check that the transformation is triggered.
+
+for ( let [ty128, ty] of [['i8x16', 'i32'], ['i16x8', 'i32'], ['i32x4', 'i32'],
+                          ['i64x2', 'i64'], ['f32x4', 'f32'], ['f64x2', 'f64']] )
+{
+    wasmCompile(`(module (func (result v128) (${ty128}.splat (${ty}.const 37))))`);
+    assertEq(wasmSimdAnalysis(), "scalar-to-simd128 -> constant folded");
+}
+
+// Ditto simd->scalar.
+
+for ( let [ty128, suffix] of [['i8x16', '_s'], ['i8x16', '_u'], ['i16x8','_s'], ['i16x8','_u'], ['i32x4', '']] ) {
+    for ( let op of ['any_true', 'all_true', 'bitmask', `extract_lane${suffix} 0`] ) {
+        let operation = op == 'any_true' ? 'v128.any_true' : `${ty128}.${op}`;
+        wasmCompile(`(module (func (result i32) (${operation} (v128.const i64x2 0 0))))`);
+        assertEq(wasmSimdAnalysis(), "simd128-to-scalar -> constant folded");
+    }
+}
+
+for ( let ty128 of ['f32x4','f64x2','i64x2'] ) {
+    wasmCompile(`(module (func (result ${ty128.match(/(...)x.*/)[1]}) (${ty128}.extract_lane 0 (v128.const i64x2 0 0))))`);
+    assertEq(wasmSimdAnalysis(), "simd128-to-scalar -> constant folded");
+}
+
+// Optimizing all_true, any_true, and bitmask that are used for control flow, also when negated.
+
+for ( let [ty128,size] of [['i8x16',1], ['i16x8',2], ['i32x4',4]] ) {
+    let all = iota(16/size).map(n => n*n);
+    let some = iota(16/size).map(n => n*(n % 3));
+    let none = iota(16/size).map(n => 0);
+    let inputs = [all, some, none];
+    let ops = { all_true: allTrue, any_true: anyTrue, bitmask };
+
+    for ( let op of ['any_true', 'all_true', 'bitmask'] ) {
+        let folded = op != 'bitmask' || (size == 2 && !isArm64);
+        let operation = op == 'any_true' ? 'v128.any_true' : `${ty128}.${op}`;
+        let positive =
+            wasmCompile(
+                `(module
+                   (memory (export "mem") 1 1)
+                   (func $f (param v128) (result i32)
+                       (if (result i32) (${operation} (local.get 0))
+                           (i32.const 42)
+                           (i32.const 37)))
+                   (func (export "run") (result i32)
+                     (call $f (v128.load (i32.const 16)))))`);
+        assertEq(wasmSimdAnalysis(), folded ? "simd128-to-scalar-and-branch -> folded" : "none");
+
+        let negative =
+            wasmCompile(
+                `(module
+                   (memory (export "mem") 1 1)
+                   (func $f (param v128) (result i32)
+                       (if (result i32) (i32.eqz (${operation} (local.get 0)))
+                           (i32.const 42)
+                           (i32.const 37)))
+                   (func (export "run") (result i32)
+                     (call $f (v128.load (i32.const 16)))))`);
+        assertEq(wasmSimdAnalysis(), folded ? "simd128-to-scalar-and-branch -> folded" : "none");
+
+        for ( let inp of inputs ) {
+            let mem = new this[`Int${8*size}Array`](positive.exports.mem.buffer);
+            set(mem, 16/size, inp);
+            assertEq(positive.exports.run(), ops[op](inp) ? 42 : 37);
+
+            mem = new this[`Int${8*size}Array`](negative.exports.mem.buffer);
+            set(mem, 16/size, inp);
+            assertEq(negative.exports.run(), ops[op](inp) ? 37 : 42);
+        }
+    }
+}
+
+// Constant folding
+
+{
+    // Swizzle-with-constant rewritten as shuffle, and then further optimized
+    // into a dword permute.  Correctness is tested in ad-hack.js.
+    wasmCompile(`
+(module (func (param v128) (result v128)
+  (i8x16.swizzle (local.get 0) (v128.const i8x16 4 5 6 7 0 1 2 3 12 13 14 15 8 9 10 11))))
+`);
+    assertEq(wasmSimdAnalysis(), "shuffle -> permute 32x4");
+}
+
+// Bitselect with constant mask folded into shuffle operation
+
+if (!isArm64) {
+  wasmCompile(`
+  (module (func (param v128) (param v128) (result v128)
+    (v128.bitselect (local.get 0) (local.get 1) (v128.const i8x16 0 -1 -1 0 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0))))
+  `);
+      assertEq(wasmSimdAnalysis(), "shuffle -> blend 8x16");  
+}
+
+// Library
+
+function wasmCompile(text) {
+    return new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(text)))
+}
+
+function get(arr, loc, len) {
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        res.push(arr[loc+i]);
+    }
+    return res;
+}
+
+function set(arr, loc, vals) {
+    for ( let i=0; i < vals.length; i++ ) {
+        arr[loc+i] = vals[i];
+    }
+}
+
+function i32ToI8(xs) {
+    return xs.map(x => [x*4, x*4+1, x*4+2, x*4+3]).flat();
+}
+
+function i64ToI2(xs) {
+  return xs.map(x => [x*8, x*8+1, x*8+2, x*8+3,
+                      x*8+4, x*8+5, x*8+6, x*8+7]).flat();
+}
+
+function i16ToI8(xs) {
+    return xs.map(x => [x*2, x*2+1]).flat();
+}
+
+function allTrue(xs) {
+    return xs.every(v => v != 0);
+}
+
+function anyTrue(xs) {
+    return xs.some(v => v != 0);
+}
+
+function bitmask(xs) {
+    let shift = 128/xs.length - 1;
+    let res = 0;
+    let k = 0;
+    xs.forEach(v => { res |= ((v >>> shift) & 1) << k; k++; });
+    return res;
+}
diff --git a/js/src/jit-test/tests/wasm/simd/ion-bug1641973.js b/js/src/jit-test/tests/wasm/simd/ion-bug1641973.js
new file mode 100644
index 0000000000..7dfdf3afad
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ion-bug1641973.js
@@ -0,0 +1,13 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Fuzz test case.  The initial unreachable will result in the subsequent
+// i8x16.shuffle popping null pointers off the value stack.  Due to a missing
+// isDeadCode() check in WasmIonCompile.cpp the compiler would dereference those
+// null pointers.
+new WebAssembly.Module(wasmTextToBinary(`
+(module
+  (func (result v128)
+    (unreachable)
+    (i8x16.shuffle 0 0 23 0 4 4 4 4 4 16 1 0 4 4 4 4)))
+`))
+
diff --git a/js/src/jit-test/tests/wasm/simd/ion-bug1688262.js b/js/src/jit-test/tests/wasm/simd/ion-bug1688262.js
new file mode 100644
index 0000000000..ebb2f72864
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ion-bug1688262.js
@@ -0,0 +1,22 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Shuffle pattern incorrectly recognized as a rotate due to a missing guard in
+// the optimizer.
+
+let ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1)
+    (func (export "test")
+      (v128.store (i32.const 0)
+        (i8x16.shuffle 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6
+                       (v128.load (i32.const 16))
+                       (v128.const i32x4 0 0 0 0)))))
+`);
+
+let mem = new Int8Array(ins.exports.mem.buffer);
+let input = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25];
+let output = [10, 11, 12, 13, 14, 15, 16, 17, 18, 10, 11, 12, 13, 14, 15, 16];
+mem.set(input, 16);
+ins.exports.test();
+let result = Array.from(mem.subarray(0, 16));
+assertDeepEq(output, result);
diff --git a/js/src/jit-test/tests/wasm/simd/ion-bug1688713.js b/js/src/jit-test/tests/wasm/simd/ion-bug1688713.js
new file mode 100644
index 0000000000..86a2ff0b3c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/ion-bug1688713.js
@@ -0,0 +1,24 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x64-test.js
+
+// This checks that we emit a REX prefix that includes the SIB index when
+// appropriate.
+//
+// This test case is a little tricky.  On Win64, the arg registers are rcx, rdx,
+// r8, r9; so we want to use local 2 or 3 as the index.  But on other x64
+// platforms, the arg registers are rdi, rsi, rdx, rcx, r8, r9; so we want to
+// use local 4 or 5 as the index.  This test uses both, and then looks for a hit
+// on the REX byte which must be 0x43.  Before the bugfix, since the index
+// register was ignored, the byte would always be 0x41, as it will continue to
+// be for the access that does not use an extended register.
+//
+// The test is brittle: the register allocator can easily make a mess of it.
+// But for now it works.
+
+codegenTestX64_adhoc(
+`(module
+   (memory 1)
+   (func $f (export "f") (param i32) (param i32) (param i32) (param i32) (param i32) (result v128)
+     (i32x4.add (v128.load8x8_s (local.get 4)) (v128.load8x8_s (local.get 2)))))`,
+    'f',
+    `66 43 0f 38 20 .. ..      pmovsxbwq \\(%r15,%r(8|9|10|11|12|13),1\\), %xmm[0-9]+`,
+    {no_prefix: true, no_suffix: true, log:true});
diff --git a/js/src/jit-test/tests/wasm/simd/js-api.js b/js/src/jit-test/tests/wasm/simd/js-api.js
new file mode 100644
index 0000000000..ea7f3fb147
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/js-api.js
@@ -0,0 +1,130 @@
+// |jit-test| test-also=--no-threads; skip-if: !wasmSimdEnabled()
+
+// SIMD JS API
+//
+// As of 31 March 2020 the SIMD spec is very light on information about the JS
+// API, and what it has is ridden with misspellings, grammatical errors, and
+// apparent redundancies.  The rules below represent my best effort at
+// understanding the intent of the spec.  As far as I can tell, the rules for
+// v128 are intended to match the rules for i64 in the Wasm MVP.
+
+// Hopefully, these are enough to test that various JIT stubs are generated and
+// used if we run the tests in a loop.
+
+setJitCompilerOption("baseline.warmup.trigger", 2);
+setJitCompilerOption("ion.warmup.trigger", 4);
+
+// RULE: v128 cannot cross the JS/wasm boundary as a function parameter.
+//
+// A wasm function that:
+//  - takes or returns v128
+//  - was imported into wasm
+//  - is ultimately a JS function
+// should always throw TypeError when called from wasm.
+//
+// Note, JIT exit stubs should be generated here because settings above should
+// cause the JIT to tier up.
+
+var ins = wasmEvalText(`
+  (module
+    (import "m" "v128_param" (func $f (param v128)))
+    (import "m" "v128_return" (func $g (result v128)))
+    (func (export "v128_param")
+      (call $f (v128.const i32x4 0 0 0 0)))
+    (func (export "v128_result")
+      (drop (call $g))))`,
+                       {m:{v128_param: (x) => 0,
+                           v128_return: () => 0}});
+
+function call_v128_param() { ins.exports.v128_param(); }
+function call_v128_result() { ins.exports.v128_result(); }
+
+for ( let i = 0 ; i < 100; i++ ) {
+    assertErrorMessage(call_v128_param,
+                       TypeError,
+                       /cannot pass.*v128.*to or from JS/);
+    assertErrorMessage(call_v128_result,
+                       TypeError,
+                       /cannot pass.*v128.*to or from JS/);
+}
+
+// RULE: v128 cannot cross the JS/wasm boundary as a function parameter.
+//
+// A wasm function that:
+//  - takes or returns v128
+//  - is exported from wasm
+//  - is ultimately a true wasm function
+// should always throw TypeError when called from JS.
+//
+// Note, JIT entry stubs should be generated here because settings above should
+// cause the JIT to tier up.
+
+var ins2 = wasmEvalText(`
+  (module
+    (func (export "v128_param") (param v128) (result i32)
+      (i32.const 0))
+    (func (export "v128_result") (result v128)
+      (v128.const i32x4 0 0 0 0)))`);
+
+function call_v128_param2() { ins2.exports.v128_param(); }
+function call_v128_result2() { ins2.exports.v128_result(); }
+
+for ( let i = 0 ; i < 100; i++ ) {
+    assertErrorMessage(call_v128_param2,
+                       TypeError,
+                       /cannot pass.*v128.*to or from JS/);
+    assertErrorMessage(call_v128_result2,
+                       TypeError,
+                       /cannot pass.*v128.*to or from JS/);
+}
+
+// RULE: The rules about v128 passing into or out of a function apply even when
+// an imported JS function is re-exported and is then called.
+
+var newfn = (x) => x;
+var ins = wasmEvalText(`
+  (module
+    (import "m" "fn" (func $f (param v128) (result v128)))
+    (export "newfn" (func $f)))`,
+                                   {m:{fn: newfn}});
+assertErrorMessage(() => ins.exports.newfn(3),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+// RULE: WebAssembly.Global of type v128 is constructable from JS with a default
+// value.
+
+
+// RULE: WebAssembly.Global constructor for type v128 is not constructable with
+// or without a default value.
+
+assertErrorMessage(() => new WebAssembly.Global({value: "v128"}, 37),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+assertErrorMessage(() => new WebAssembly.Global({value: "v128"}),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+assertErrorMessage(() => new WebAssembly.Global({value: "v128", mutable: true}),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+// RULE: WebAssembly.Global of type v128 have getters and setters that throw
+// TypeError when called from JS.
+
+let {gi, gm} = wasmEvalText(`
+  (module
+    (global (export "gi") v128 v128.const i64x2 0 0)
+    (global (export "gm") (mut v128) v128.const i64x2 0 0)
+  )`).exports;
+
+assertErrorMessage(() => gi.value,
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+assertErrorMessage(() => gi.valueOf(),
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+assertErrorMessage(() => gm.value = 0,
+                   TypeError,
+                   /cannot pass.*v128.*to or from JS/);
+
+
diff --git a/js/src/jit-test/tests/wasm/simd/neg-abs-not-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/neg-abs-not-x64-ion-codegen.js
new file mode 100644
index 0000000000..0ae75f38fb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/neg-abs-not-x64-ion-codegen.js
@@ -0,0 +1,34 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// Test that there are no extraneous moves for variable SIMD negate, abs, and
+// not instructions. See README-codegen.md for general information about this
+// type of test case.
+
+// Integer negates don't have to reuse the input for the output, and prefer for
+// the registers to be different.  So use parameter 1 and ignore parameter 0.
+
+codegenTestX64_IGNOREDxv128_v128(
+    [['i8x16.neg', `
+66 0f ef c0               pxor %xmm0, %xmm0
+66 0f f8 c1               psubb %xmm1, %xmm0`],
+     ['i16x8.neg', `
+66 0f ef c0               pxor %xmm0, %xmm0
+66 0f f9 c1               psubw %xmm1, %xmm0`],
+     ['i32x4.neg', `
+66 0f ef c0               pxor %xmm0, %xmm0
+66 0f fa c1               psubd %xmm1, %xmm0`],
+     ['i64x2.neg', `
+66 0f ef c0               pxor %xmm0, %xmm0
+66 0f fb c1               psubq %xmm1, %xmm0`]] );
+
+// Floating point negate and absolute value, and bitwise not, prefer for the
+// registers to be the same and guarantee that no move is inserted if so.
+
+codegenTestX64_v128_v128(
+    [['f32x4.neg', `66 0f ef 05 ${RIPRADDR}   pxorx ${RIPR}, %xmm0`],
+     ['f64x2.neg', `66 0f ef 05 ${RIPRADDR}   pxorx ${RIPR}, %xmm0`],
+     ['f32x4.abs', `66 0f db 05 ${RIPRADDR}   pandx ${RIPR}, %xmm0`],
+     ['f64x2.abs', `66 0f db 05 ${RIPRADDR}   pandx ${RIPR}, %xmm0`],
+     ['v128.not', `
+66 45 0f 75 ff            pcmpeqw %xmm15, %xmm15
+66 41 0f ef c7            pxor %xmm15, %xmm0`]] );
diff --git a/js/src/jit-test/tests/wasm/simd/pairwise-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/pairwise-x64-ion-codegen.js
new file mode 100644
index 0000000000..53ab47fdb8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/pairwise-x64-ion-codegen.js
@@ -0,0 +1,38 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// Tests for SIMD add pairwise instructions.
+
+if (!isAvxPresent()) {
+
+     codegenTestX64_IGNOREDxv128_v128(
+          [['i16x8.extadd_pairwise_i8x16_s', `
+66 0f 6f 05 ${RIPRADDR}    movdqax ${RIPR}, %xmm0
+66 0f 38 04 c1             pmaddubsw %xmm1, %xmm0`],
+           ['i16x8.extadd_pairwise_i8x16_u', `
+66 0f 6f c1                movdqa %xmm1, %xmm0
+66 0f 38 04 05 ${RIPRADDR} pmaddubswx ${RIPR}, %xmm0`],
+           ['i32x4.extadd_pairwise_i16x8_s', `
+66 0f 6f c1                movdqa %xmm1, %xmm0
+66 0f f5 05 ${RIPRADDR}    pmaddwdx ${RIPR}, %xmm0`],
+           ['i32x4.extadd_pairwise_i16x8_u', `
+66 0f 6f c1                movdqa %xmm1, %xmm0
+66 0f ef 05 ${RIPRADDR}    pxorx ${RIPR}, %xmm0
+66 0f f5 05 ${RIPRADDR}    pmaddwdx ${RIPR}, %xmm0
+66 0f fe 05 ${RIPRADDR}    padddx ${RIPR}, %xmm0`]]);
+
+} else {
+
+     codegenTestX64_IGNOREDxv128_v128(
+          [['i16x8.extadd_pairwise_i8x16_s', `
+66 0f 6f 05 ${RIPRADDR}    movdqax ${RIPR}, %xmm0
+66 0f 38 04 c1             pmaddubsw %xmm1, %xmm0`],
+           ['i16x8.extadd_pairwise_i8x16_u', `
+c4 e2 71 04 05 ${RIPRADDR} vpmaddubswx ${RIPR}, %xmm1, %xmm0`],
+           ['i32x4.extadd_pairwise_i16x8_s', `
+c5 f1 f5 05 ${RIPRADDR}    vpmaddwdx ${RIPR}, %xmm1, %xmm0`],
+           ['i32x4.extadd_pairwise_i16x8_u', `
+c5 f1 ef 05 ${RIPRADDR}    vpxorx ${RIPR}, %xmm1, %xmm0
+66 0f f5 05 ${RIPRADDR}    pmaddwdx ${RIPR}, %xmm0
+66 0f fe 05 ${RIPRADDR}    padddx ${RIPR}, %xmm0`]]);
+
+}
diff --git a/js/src/jit-test/tests/wasm/simd/pmaddubsw-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/pmaddubsw-x64-ion-codegen.js
new file mode 100644
index 0000000000..94abfd5c54
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/pmaddubsw-x64-ion-codegen.js
@@ -0,0 +1,154 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || wasmCompileMode() != "ion"
+
+// Testing _mm_maddubs_epi16 / vpmaddubsw behavoir for all platforms.
+//
+// Bug 1762413 adds specialization for emscripten's pattern to directly
+// emit PMADDUBSW machine code.
+
+const isX64 = getBuildConfiguration().x64 && !getBuildConfiguration().simulator;
+
+// Simple test.
+const simple = wasmTextToBinary(`(module 
+  (memory (export "memory") 1 1)
+  (func $_mm_maddubs_epi16 (export "t") (param v128 v128) (result v128)
+    local.get 1
+    i32.const 8
+    i16x8.shl
+    i32.const 8
+    i16x8.shr_s
+    local.get 0
+    v128.const i32x4 0x00ff00ff 0x00ff00ff 0x00ff00ff 0x00ff00ff
+    v128.and
+    i16x8.mul
+    local.get 1
+    i32.const 8
+    i16x8.shr_s
+    local.get 0
+    i32.const 8
+    i16x8.shr_u
+    i16x8.mul
+    i16x8.add_sat_s)
+  (func (export "run")
+    i32.const 0
+    v128.const i8x16 0 2 1 2 1  2  -1   1    255 255 255 255   0 0 255 255 
+    v128.const i8x16 1 0 3 4 -3 -4 -128 127  127 127 -128 -128 0 0 -128 127 
+    call $_mm_maddubs_epi16
+    v128.store
+  )
+)`);
+var ins = new WebAssembly.Instance(new WebAssembly.Module(simple));
+ins.exports.run();
+var mem16 = new Int16Array(ins.exports.memory.buffer, 0, 8);
+assertSame(mem16, [0, 11, -11, -32513, 32767, -32768, 0, -255]);
+
+if (hasDisassembler() && isX64) {
+  assertEq(wasmDis(ins.exports.t, {tier:"ion", asString:true}).includes('pmaddubsw'), true);
+}
+
+if (hasDisassembler() && isX64) {
+  // Two pmaddubsw has common operand, and code was optimized.
+  const realWorldOutput = wasmTextToBinary(`(module
+     (memory 1 1)
+     (func (export "test")
+         (local i32 i32 i32 i32 v128 v128 v128 v128 v128 v128)
+         local.get 0
+         local.get 1
+         i32.add
+         local.set 2
+         local.get 0
+         i32.const 16
+         i32.add
+         local.set 0
+         local.get 3
+         local.set 1
+         loop
+             local.get 5
+             local.get 0
+             v128.load
+             local.tee 5
+             i32.const 7
+             i8x16.shr_s
+             local.tee 8
+             local.get 1
+             v128.load offset=240
+             local.get 5
+             v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000
+             i8x16.eq
+             local.tee 7
+             v128.andnot
+             i8x16.add
+             local.get 8
+             v128.xor
+             local.tee 4
+             i32.const 8
+             i16x8.shl
+             i32.const 8
+             i16x8.shr_s
+             local.get 5
+             i8x16.abs
+             local.tee 5
+             v128.const i32x4 0x00ff00ff 0x00ff00ff 0x00ff00ff 0x00ff00ff
+             v128.and
+             local.tee 9
+             i16x8.mul
+             local.get 4
+             i32.const 8
+             i16x8.shr_s
+             local.get 5
+             i32.const 8
+             i16x8.shr_u
+             local.tee 4
+             i16x8.mul
+             i16x8.add_sat_s
+             i16x8.add_sat_s
+             local.set 5
+ 
+             local.get 6
+             local.get 8
+             local.get 1
+             v128.load offset=224
+             local.get 7
+             v128.andnot
+             i8x16.add
+             local.get 8
+             v128.xor
+             local.tee 6
+             i32.const 8
+             i16x8.shl
+             i32.const 8
+             i16x8.shr_s
+             local.get 9
+             i16x8.mul
+             local.get 6
+             i32.const 8
+             i16x8.shr_s
+             local.get 4
+             i16x8.mul
+             i16x8.add_sat_s
+             i16x8.add_sat_s
+             local.set 6
+ 
+             local.get 1
+             i32.const 128
+             i32.add
+             local.set 1
+             local.get 0
+             i32.const 16
+             i32.add
+             local.tee 0
+             local.get 2
+             i32.ne
+             br_if 0
+         end
+))`);
+ 
+  var ins = new WebAssembly.Instance(new WebAssembly.Module(realWorldOutput));
+  const output = wasmDis(ins.exports.test, {tier:"ion", asString:true}).replace(/^[0-9a-f]{8}  (?:[0-9a-f]{2} )+\n?\s+/gmi, "");
+  // Find two pmaddubsw+paddsw.
+  const re = /\bv?pmaddubsw[^\n]+\nv?paddsw /g;
+  assertEq(re.exec(output) != null, true);
+  assertEq(re.exec(output) != null, true);
+  assertEq(re.exec(output) == null, true);
+  // No leftover PMULL, PSLLW, or PSRAW.
+  assertEq(/pmullw|psllw|psraw/.test(output), false);
+}
diff --git a/js/src/jit-test/tests/wasm/simd/reduce-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/reduce-x64-ion-codegen.js
new file mode 100644
index 0000000000..bd59f30632
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/reduce-x64-ion-codegen.js
@@ -0,0 +1,46 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x64-test.js
+
+// Test encoding of the all_true, and any_true operations.
+
+codegenTestX64_v128_i32(
+     [['v128.any_true', `
+66 0f 38 17 c0            ptest %xmm0, %xmm0
+0f 95 c0                  setnz %al
+0f b6 c0                  movzx %al, %eax`],
+     ['i8x16.all_true', `
+66 45 0f ef ff            pxor %xmm15, %xmm15
+66 44 0f 74 f8            pcmpeqb %xmm0, %xmm15
+66 45 0f 38 17 ff         ptest %xmm15, %xmm15
+0f 94 c0                  setz %al
+0f b6 c0                  movzx %al, %eax`],
+     ['i16x8.all_true', `
+66 45 0f ef ff            pxor %xmm15, %xmm15
+66 44 0f 75 f8            pcmpeqw %xmm0, %xmm15
+66 45 0f 38 17 ff         ptest %xmm15, %xmm15
+0f 94 c0                  setz %al
+0f b6 c0                  movzx %al, %eax`],
+     ['i32x4.all_true', `
+66 45 0f ef ff            pxor %xmm15, %xmm15
+66 44 0f 76 f8            pcmpeqd %xmm0, %xmm15
+66 45 0f 38 17 ff         ptest %xmm15, %xmm15
+0f 94 c0                  setz %al
+0f b6 c0                  movzx %al, %eax`],
+     ['i64x2.all_true', `
+66 45 0f ef ff            pxor %xmm15, %xmm15
+66 44 0f 38 29 f8         pcmpeqq %xmm0, %xmm15
+66 45 0f 38 17 ff         ptest %xmm15, %xmm15
+0f 94 c0                  setz %al
+0f b6 c0                  movzx %al, %eax`]], {}
+)
+
+// Utils.
+function codegenTestX64_v128_i32(inputs, options = {}) {
+     for ( let [op, expected] of inputs ) {
+         codegenTestX64_adhoc(wrap(options, `
+     (func (export "f") (param v128) (result i32)
+       (${op} (local.get 0)))`),
+                              'f',
+                              expected,
+                              options);
+     }
+ }
diff --git a/js/src/jit-test/tests/wasm/simd/select.js b/js/src/jit-test/tests/wasm/simd/select.js
new file mode 100644
index 0000000000..b3535d3039
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/select.js
@@ -0,0 +1,33 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+wasmAssert(`
+(module
+ (func $f (param i32) (result v128)
+  (select ;; no type
+   (v128.const i32x4 1 2 3 4)
+   (v128.const i32x4 4 3 2 1)
+   (local.get 0)
+  )
+ )
+ (export "" (func 0))
+)`, [
+    { type: 'v128', func: '$f', args: ['i32.const  0'], expected: 'i32x4 4 3 2 1' },
+    { type: 'v128', func: '$f', args: ['i32.const  1'], expected: 'i32x4 1 2 3 4' },
+    { type: 'v128', func: '$f', args: ['i32.const -1'], expected: 'i32x4 1 2 3 4' },
+], {});
+
+wasmAssert(`
+(module
+ (func $f (param i32) (result v128)
+  (select (result v128)
+   (v128.const i32x4 1 2 3 4)
+   (v128.const i32x4 4 3 2 1)
+   (local.get 0)
+  )
+ )
+ (export "" (func 0))
+)`, [
+    { type: 'v128', func: '$f', args: ['i32.const  0'], expected: 'i32x4 4 3 2 1' },
+    { type: 'v128', func: '$f', args: ['i32.const  1'], expected: 'i32x4 1 2 3 4' },
+    { type: 'v128', func: '$f', args: ['i32.const -1'], expected: 'i32x4 1 2 3 4' },
+], {});
diff --git a/js/src/jit-test/tests/wasm/simd/shift-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/shift-x64-ion-codegen.js
new file mode 100644
index 0000000000..9c9f4871d2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/shift-x64-ion-codegen.js
@@ -0,0 +1,26 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator; include:codegen-x64-test.js
+
+// Test that there are no extraneous moves for a constant integer SIMD shift
+// that can reuse its input for its output.  See README-codegen.md for general
+// information about this type of test case.
+//
+// There are test cases here for all codegen cases that include a potential move
+// to set up the operation, but not for all shift operations in general.
+
+codegenTestX64_v128xLITERAL_v128(
+    [['i8x16.shl', '(i32.const 2)', `
+66 0f fc c0               paddb %xmm0, %xmm0
+66 0f fc c0               paddb %xmm0, %xmm0`],
+     ['i16x8.shl', '(i32.const 2)', `66 0f 71 f0 02            psllw \\$0x02, %xmm0`],
+     ['i32x4.shl', '(i32.const 2)', `66 0f 72 f0 02            pslld \\$0x02, %xmm0`],
+     ['i64x2.shl', '(i32.const 2)', `66 0f 73 f0 02            psllq \\$0x02, %xmm0`],
+     ['i8x16.shr_u', '(i32.const 2)', `
+66 0f db 05 ${RIPRADDR}   pandx ${RIPR}, %xmm0
+66 0f 71 d0 02            psrlw \\$0x02, %xmm0`],
+     ['i16x8.shr_s', '(i32.const 2)', `66 0f 71 e0 02            psraw \\$0x02, %xmm0`],
+     ['i16x8.shr_u', '(i32.const 2)', `66 0f 71 d0 02            psrlw \\$0x02, %xmm0`],
+     ['i32x4.shr_s', '(i32.const 2)', `66 0f 72 e0 02            psrad \\$0x02, %xmm0`],
+     ['i32x4.shr_u', '(i32.const 2)', `66 0f 72 d0 02            psrld \\$0x02, %xmm0`],
+     ['i64x2.shr_u', '(i32.const 2)', `66 0f 73 d0 02            psrlq \\$0x02, %xmm0`]] );
+
+
diff --git a/js/src/jit-test/tests/wasm/simd/shuffle-x86-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/shuffle-x86-ion-codegen.js
new file mode 100644
index 0000000000..b9d0cc0e82
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/shuffle-x86-ion-codegen.js
@@ -0,0 +1,88 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x64-test.js
+
+// Test that there are no extraneous moves or fixups for SIMD shuffle
+// operations.  See README-codegen.md for general information about this type of
+// test case.
+
+codegenTestX64_v128xv128_v128([
+     // Identity op on first argument should generate no code
+    ['i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15',
+     ''],
+
+     // Identity op on second argument should generate a move
+    ['i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31',
+     `66 0f 6f c1               movdqa %xmm1, %xmm0`],
+
+     // Broadcast a byte from first argument
+    ['i8x16.shuffle 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5',
+     `
+66 0f 60 c0               punpcklbw %xmm0, %xmm0
+f3 0f 70 c0 55            pshufhw \\$0x55, %xmm0, %xmm0
+66 0f 70 c0 aa            pshufd \\$0xAA, %xmm0, %xmm0`],
+
+     // Broadcast a word from first argument
+    ['i8x16.shuffle 4 5 4 5 4 5 4 5 4 5 4 5 4 5 4 5',
+     `
+f2 0f 70 c0 aa            pshuflw \\$0xAA, %xmm0, %xmm0
+66 0f 70 c0 00            pshufd \\$0x00, %xmm0, %xmm0`],
+
+     // Permute bytes
+    ['i8x16.shuffle 2 1 4 3 6 5 8 7 10 9 12 11 14 13 0 15',
+`
+66 0f 38 00 05 ${RIPRADDR} pshufbx ${RIPR}, %xmm0`],
+
+     // Permute words
+    ['i8x16.shuffle 2 3 0 1 6 7 4 5 10 11 8 9 14 15 12 13',
+`
+f2 0f 70 c0 b1            pshuflw \\$0xB1, %xmm0, %xmm0
+f3 0f 70 c0 b1            pshufhw \\$0xB1, %xmm0, %xmm0`],
+
+     // Permute doublewords
+    ['i8x16.shuffle 4 5 6 7 0 1 2 3 12 13 14 15 8 9 10 11',
+     `66 0f 70 c0 b1            pshufd \\$0xB1, %xmm0, %xmm0`],
+
+     // Rotate right
+    ['i8x16.shuffle 13 14 15 0 1 2 3 4 5 6 7 8 9 10 11 12',
+     `66 0f 3a 0f c0 0d         palignr \\$0x0D, %xmm0, %xmm0`],
+
+     // General shuffle + blend.  The initial movdqa to scratch is unavoidable
+     // unless we can convince the compiler that it's OK to destroy xmm1.
+    ['i8x16.shuffle 15 29 0 1 2 1 2 0 3 4 7 8 16 8 17 9',
+`
+66 44 0f 6f f9                movdqa %xmm1, %xmm15
+66 44 0f 38 00 3d ${RIPRADDR} pshufbx ${RIPR}, %xmm15
+66 0f 38 00 05 ${RIPRADDR}    pshufbx ${RIPR}, %xmm0
+66 41 0f eb c7                por %xmm15, %xmm0`]]);
+
+codegenTestX64_v128xLITERAL_v128(
+    [// Shift left bytes, shifting in zeroes
+     //
+     // Remember the low-order bytes are at the "right" end
+     //
+     // The pxor is a code generation bug: the operand is unused, and no
+     // code should need to be generated for it, and no register should
+     // be allocated to it.  The lowering does not use that operand, but
+     // code generation still touches it.
+     ['i8x16.shuffle 16 16 16 0 1 2 3 4 5 6 7 8 9 10 11 12',
+      '(v128.const i32x4 0 0 0 0)',
+`
+66 0f 73 f8 03            pslldq \\$0x03, %xmm0`],
+
+     // Shift right bytes, shifting in zeroes.  See above.
+     ['i8x16.shuffle 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18',
+      '(v128.const i32x4 0 0 0 0)',
+`
+66 0f 73 d8 03            psrldq \\$0x03, %xmm0`]]);
+
+// SSE4.1 PBLENDVB instruction is using XMM0, checking if blend
+// operation generated as expected.
+codegenTestX64_adhoc(
+     `(func (export "f") (param v128 v128 v128 v128) (result v128)
+        (i8x16.shuffle 0 17 2 3 4 5 6 7 24 25 26 11 12 13 30 15
+          (local.get 2)(local.get 3)))`,
+     'f',
+`
+66 0f 6f ca               movdqa %xmm2, %xmm1
+66 0f 6f 05 ${RIPRADDR}   movdqax ${RIPR}, %xmm0
+66 0f 38 10 cb            pblendvb %xmm3, %xmm1
+66 0f 6f c1               movdqa %xmm1, %xmm0`);
diff --git a/js/src/jit-test/tests/wasm/simd/simd-partial-oob-store.js b/js/src/jit-test/tests/wasm/simd/simd-partial-oob-store.js
new file mode 100644
index 0000000000..00daceb438
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/simd-partial-oob-store.js
@@ -0,0 +1,38 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+// Cloned from ad-hack.js but kept separate because it may have to be disabled
+// on some devices until bugs are fixed.
+
+// Bug 1666747 - partially OOB stores are not handled correctly on ARM and ARM64.
+// The simulators don't implement the correct semantics anyhow, so when the bug
+// is fixed in the code generator they must remain excluded here.
+var conf = getBuildConfiguration();
+if (conf.arm64 || conf["arm64-simulator"] || conf.arm || conf["arm-simulator"])
+    quit(0);
+
+function get(arr, loc, len) {
+    let res = [];
+    for ( let i=0; i < len; i++ ) {
+        res.push(arr[loc+i]);
+    }
+    return res;
+}
+
+for ( let offset of iota(16) ) {
+    var ins = wasmEvalText(`
+  (module
+    (memory (export "mem") 1 1)
+    (func (export "f") (param $loc i32)
+      (v128.store offset=${offset} (local.get $loc) (v128.const i32x4 ${1+offset} 2 3 ${4+offset*2}))))`);
+
+    // OOB write should trap
+    assertErrorMessage(() => ins.exports.f(65536-15),
+                       WebAssembly.RuntimeError,
+                       /index out of bounds/)
+
+    // Ensure that OOB writes don't write anything.
+    let start = 65536 - 15 + offset;
+    let legalBytes = 65536 - start;
+    var mem8 = new Uint8Array(ins.exports.mem.buffer);
+    assertSame(get(mem8, start, legalBytes), iota(legalBytes).map((_) => 0));
+}
diff --git a/js/src/jit-test/tests/wasm/simd/splat-x64-ion-codegen.js b/js/src/jit-test/tests/wasm/simd/splat-x64-ion-codegen.js
new file mode 100644
index 0000000000..ce1d7adb12
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/splat-x64-ion-codegen.js
@@ -0,0 +1,29 @@
+// |jit-test| skip-if: !wasmSimdEnabled() || !hasDisassembler() || wasmCompileMode() != "ion" || !getBuildConfiguration().x64 || getBuildConfiguration().simulator || isAvxPresent(); include:codegen-x64-test.js
+
+// Test that there are no extraneous moves or other instructions for splat and
+// other splat-like operations that can reuse its input for its output and/or
+// has a specializable code path.  See README-codegen.md for general information
+// about this type of test case.
+
+codegenTestX64_PTYPE_v128(
+    [['f32x4.splat', 'f32', `0f c6 c0 00               shufps \\$0x00, %xmm0, %xmm0`],
+     ['f64x2.splat', 'f64', `f2 0f 12 c0               movddup %xmm0, %xmm0`]] , {log:true});
+
+// Skip these on Win64 because the ABI differs and there's a different parameter
+// register, this changes not just the name slightly but the binary encoding in
+// larger ways.
+
+if (!getBuildConfiguration().windows) {
+    codegenTestX64_PTYPE_v128(
+        [['v128.load32_splat', 'i32', `
+f3 41 0f 10 04 3f         movssl \\(%r15,%rdi,1\\), %xmm0
+0f c6 c0 00               shufps \\$0x00, %xmm0, %xmm0`],
+         ['v128.load64_splat', 'i32', `f2 41 0f 12 04 3f         movddupq \\(%r15,%rdi,1\\), %xmm0`],
+         ['v128.load8x8_s',    'i32', `66 41 0f 38 20 04 3f      pmovsxbwq \\(%r15,%rdi,1\\), %xmm0`],
+         ['v128.load8x8_u',    'i32', `66 41 0f 38 30 04 3f      pmovzxbwq \\(%r15,%rdi,1\\), %xmm0`],
+         ['v128.load16x4_s',   'i32', `66 41 0f 38 23 04 3f      pmovsxwdq \\(%r15,%rdi,1\\), %xmm0`],
+         ['v128.load16x4_u',   'i32', `66 41 0f 38 33 04 3f      pmovzxwdq \\(%r15,%rdi,1\\), %xmm0`],
+         ['v128.load32x2_s',   'i32', `66 41 0f 38 25 04 3f      pmovsxdqq \\(%r15,%rdi,1\\), %xmm0`],
+         ['v128.load32x2_u',   'i32', `66 41 0f 38 35 04 3f      pmovzxdqq \\(%r15,%rdi,1\\), %xmm0`]],
+        {memory:1});
+}
diff --git a/js/src/jit-test/tests/wasm/simd/validation.js b/js/src/jit-test/tests/wasm/simd/validation.js
new file mode 100644
index 0000000000..46b8df620f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/simd/validation.js
@@ -0,0 +1,368 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+function testValid(code) {
+    assertEq(WebAssembly.validate(wasmTextToBinary(code)), true);
+}
+
+function testInvalid(code) {
+    assertEq(WebAssembly.validate(wasmTextToBinary(code)), false);
+}
+
+// v128 -> v128
+
+for (let op of [
+    'i8x16.neg',
+    'i8x16.abs',
+    'i16x8.neg',
+    'i16x8.abs',
+    'i16x8.extend_low_i8x16_s',
+    'i16x8.extend_high_i8x16_s',
+    'i16x8.extend_low_i8x16_u',
+    'i16x8.extend_high_i8x16_u',
+    'i32x4.neg',
+    'i32x4.abs',
+    'i32x4.extend_low_i16x8_s',
+    'i32x4.extend_high_i16x8_s',
+    'i32x4.extend_low_i16x8_u',
+    'i32x4.extend_high_i16x8_u',
+    'i32x4.trunc_sat_f32x4_s',
+    'i32x4.trunc_sat_f32x4_u',
+    'i64x2.neg',
+    'f32x4.abs',
+    'f32x4.neg',
+    'f32x4.sqrt',
+    'f32x4.convert_i32x4_s',
+    'f32x4.convert_i32x4_s',
+    'f64x2.abs',
+    'f64x2.neg',
+    'f64x2.sqrt',
+    'v128.not'])
+{
+    testValid(`(module
+                 (func (param v128) (result v128)
+                   (${op} (local.get 0))))`);
+}
+
+for (let [prefix, result, suffix] of [['i8x16', 'i32', '_s'],
+                                      ['i8x16', 'i32', '_u'],
+                                      ['i16x8', 'i32', '_s'],
+                                      ['i16x8', 'i32', '_u'],
+                                      ['i32x4', 'i32', ''],
+                                      ['i64x2', 'i64', ''],
+                                      ['f32x4', 'f32', ''],
+                                      ['f64x2', 'f64', '']])
+{
+    testValid(`(module
+                 (func (param v128) (result ${result})
+                   (${prefix}.extract_lane${suffix} 1 (local.get 0))))`);
+}
+
+// The wat parser accepts small out-of-range lane indices, but they must be
+// caught in validation.
+
+testInvalid(
+    `(module
+       (func (param v128) (result i32)
+         (i8x16.extract_lane_u 16 (local.get 0))))`);
+
+// (v128, v128) -> v128
+
+for (let op of [
+    'i8x16.eq',
+    'i8x16.ne',
+    'i8x16.lt_s',
+    'i8x16.lt_u',
+    'i8x16.gt_s',
+    'i8x16.gt_u',
+    'i8x16.le_s',
+    'i8x16.le_u',
+    'i8x16.ge_s',
+    'i8x16.ge_u',
+    'i16x8.eq',
+    'i16x8.ne',
+    'i16x8.lt_s',
+    'i16x8.lt_u',
+    'i16x8.gt_s',
+    'i16x8.gt_u',
+    'i16x8.le_s',
+    'i16x8.le_u',
+    'i16x8.ge_s',
+    'i16x8.ge_u',
+    'i32x4.eq',
+    'i32x4.ne',
+    'i32x4.lt_s',
+    'i32x4.lt_u',
+    'i32x4.gt_s',
+    'i32x4.gt_u',
+    'i32x4.le_s',
+    'i32x4.le_u',
+    'i32x4.ge_s',
+    'i32x4.ge_u',
+    'f32x4.eq',
+    'f32x4.ne',
+    'f32x4.lt',
+    'f32x4.gt',
+    'f32x4.le',
+    'f32x4.ge',
+    'f64x2.eq',
+    'f64x2.ne',
+    'f64x2.lt',
+    'f64x2.gt',
+    'f64x2.le',
+    'f64x2.ge',
+    'v128.and',
+    'v128.or',
+    'v128.xor',
+    'v128.andnot',
+    'i8x16.avgr_u',
+    'i16x8.avgr_u',
+    'i8x16.add',
+    'i8x16.add_sat_s',
+    'i8x16.add_sat_u',
+    'i8x16.sub',
+    'i8x16.sub_sat_s',
+    'i8x16.sub_sat_u',
+    'i8x16.min_s',
+    'i8x16.max_s',
+    'i8x16.min_u',
+    'i8x16.max_u',
+    'i16x8.add',
+    'i16x8.add_sat_s',
+    'i16x8.add_sat_u',
+    'i16x8.sub',
+    'i16x8.sub_sat_s',
+    'i16x8.sub_sat_u',
+    'i16x8.mul',
+    'i16x8.min_s',
+    'i16x8.max_s',
+    'i16x8.min_u',
+    'i16x8.max_u',
+    'i32x4.add',
+    'i32x4.sub',
+    'i32x4.mul',
+    'i32x4.min_s',
+    'i32x4.max_s',
+    'i32x4.min_u',
+    'i32x4.max_u',
+    'i64x2.add',
+    'i64x2.sub',
+    'i64x2.mul',
+    'f32x4.add',
+    'f32x4.sub',
+    'f32x4.mul',
+    'f32x4.div',
+    'f32x4.min',
+    'f32x4.max',
+    'f64x2.add',
+    'f64x2.sub',
+    'f64x2.mul',
+    'f64x2.div',
+    'f64x2.min',
+    'f64x2.max',
+    'i8x16.narrow_i16x8_s',
+    'i8x16.narrow_i16x8_u',
+    'i16x8.narrow_i32x4_s',
+    'i16x8.narrow_i32x4_u',
+    'i8x16.swizzle'])
+{
+    testValid(`(module
+                 (func (param v128) (param v128) (result v128)
+                   (${op} (local.get 0) (local.get 1))))`);
+}
+
+testValid(`(module
+             (func (param v128) (param v128) (result v128)
+               (i8x16.shuffle 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 (local.get 0) (local.get 1))))`);
+
+assertErrorMessage(() => testValid(
+    `(module
+       (func (param v128) (param v128) (result v128)
+         (i8x16.shuffle 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 (local.get 0) (local.get 1))))`),
+                   SyntaxError,
+                   /expected a u8/);
+
+// (v128, i32) -> v128
+
+for (let op of [
+    'i8x16.shl',
+    'i8x16.shr_s',
+    'i8x16.shr_u',
+    'i16x8.shl',
+    'i16x8.shr_s',
+    'i16x8.shr_u',
+    'i32x4.shl',
+    'i32x4.shr_s',
+    'i32x4.shr_u',
+    'i64x2.shl',
+    'i64x2.shr_s',
+    'i64x2.shr_u'])
+{
+    testValid(`(module
+                 (func (param v128) (param i32) (result v128)
+                   (${op} (local.get 0) (local.get 1))))`);
+}
+
+// v128 -> i32
+
+for (let op of [
+    'v128.any_true',
+    'i8x16.all_true',
+    'i16x8.all_true',
+    'i32x4.all_true',
+    'i8x16.bitmask',
+    'i16x8.bitmask',
+    'i32x4.bitmask'])
+{
+    testValid(`(module
+                 (func (param v128) (result i32)
+                   (${op} (local.get 0))))`);
+}
+
+// T -> V128
+
+for (let [op, input] of [
+    ['i8x16.splat', 'i32'],
+    ['i16x8.splat', 'i32'],
+    ['i32x4.splat', 'i32'],
+    ['i64x2.splat', 'i64'],
+    ['f32x4.splat', 'f32'],
+    ['f64x2.splat', 'f64']])
+{
+    testValid(`(module
+                 (func (param ${input}) (result v128)
+                   (${op} (local.get 0))))`);
+}
+
+// i32 -> v128
+
+for (let op of [
+    'v128.load',
+    'v128.load8_splat',
+    'v128.load16_splat',
+    'v128.load32_splat',
+    'v128.load64_splat',
+    'v128.load8x8_s',
+    'v128.load8x8_u',
+    'v128.load16x4_s',
+    'v128.load16x4_u',
+    'v128.load32x2_s',
+    'v128.load32x2_u'])
+{
+    testValid(`(module
+                 (memory 1 1)
+                 (func (param i32) (result v128)
+                   (${op} (local.get 0))))`);
+}
+
+testValid(`(module
+             (func (result v128)
+               (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+             (func (result v128)
+               (v128.const i16x8 0 1 2 3 4 5 6 7))
+             (func (result v128)
+               (v128.const i32x4 0 1 2 3))
+             (func (result v128)
+               (v128.const i64x2 0 1))
+             (func (result v128)
+               (v128.const f32x4 0 1 2 3))
+             (func (result v128)
+               (v128.const f32x4 0.5 1.5 2.5 3.5))
+             (func (result v128)
+               (v128.const f64x2 0 1))
+             (func (result v128)
+               (v128.const f64x2 0.5 1.5)))`);
+
+assertErrorMessage(() => testValid(
+    `(module
+       (func (result v128)
+         (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)))`),
+                   SyntaxError,
+                   /expected a i8/);
+
+assertErrorMessage(() => testValid(
+    `(module
+       (func (result v128)
+         (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 256 15)))`),
+                   SyntaxError,
+                   /invalid i8 number/);
+
+assertErrorMessage(() => testValid(
+    `(module
+       (func (result v128)
+         (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 3.14 15)))`),
+                   SyntaxError,
+                   /expected a i8/);
+
+assertErrorMessage(() => testValid(
+    `(module
+       (func (result v128)
+         (v128.const f32x4 0.5 1.5 2.5))`),
+                   SyntaxError,
+                   /expected a float/);
+
+assertErrorMessage(() => testValid(
+    `(module
+       (func (result v128)
+         (v128.const i8x8 0 1 2 3 4 5 6 7)))`),
+                   SyntaxError,
+                   /expected one of/);
+
+// v128 -> ()
+
+testValid(`(module
+             (memory 1 1)
+             (func (param i32) (param v128)
+               (v128.store (local.get 0) (local.get 1))))`);
+
+// (v128, v128, v128) -> v128
+
+testValid(`(module
+             (func (param v128) (param v128) (param v128) (result v128)
+               (v128.bitselect (local.get 0) (local.get 1) (local.get 2))))`);
+
+// (v128, t) -> v128
+
+for (let [prefix, input] of [['i8x16', 'i32'],
+                             ['i16x8', 'i32'],
+                             ['i32x4', 'i32'],
+                             ['i64x2', 'i64'],
+                             ['f32x4', 'f32'],
+                             ['f64x2', 'f64']])
+{
+    testValid(`(module
+                 (func (param v128) (param ${input}) (result v128)
+                   (${prefix}.replace_lane 1 (local.get 0) (local.get 1))))`);
+}
+
+testInvalid(
+    `(module
+       (func (param v128) (param i32) (result v128)
+         (i8x16.replace_lane 16 (local.get 0) (local.get 1))))`);
+
+// Global variables
+
+testValid(`(module
+             (global $g (mut v128) (v128.const f32x4 1 2 3 4)))`);
+
+testValid(`(module
+             (global $g (import "m" "g") v128)
+             (global $h (mut v128) (global.get $g)))`);
+
+testValid(`(module
+             (global $g (export "g") v128 (v128.const f32x4 1 2 3 4)))`);
+
+testValid(`(module
+             (global $g (export "g") (mut v128) (v128.const f32x4 1 2 3 4)))`);
+
+// Imports, exports, calls
+
+testValid(`(module
+             (import "m" "g" (func (param v128) (result v128)))
+             (func (export "f") (param v128) (result v128)
+               (f64x2.add (local.get 0) (v128.const f64x2 1 2))))`);
+
+testValid(`(module
+             (func $f (param v128) (result v128)
+               (i8x16.neg (local.get 0)))
+             (func $g (export "g") (param v128) (result v128)
+               (call $f (local.get 0))))`);
diff --git a/js/src/jit-test/tests/wasm/single-cpu.js b/js/src/jit-test/tests/wasm/single-cpu.js
new file mode 100644
index 0000000000..afc4beee84
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/single-cpu.js
@@ -0,0 +1,23 @@
+// |jit-test| --test-wasm-await-tier2; --cpu-count=1
+
+// Test that compilation works when there's only one core available.
+
+// This is fac-opt from fac.wast in the official testsuite, changed to use
+// i32 instead of i64.
+assertEq(wasmEvalText(`(module
+  (func $fac-opt (param i32) (result i32)
+    (local i32)
+    (local.set 1 (i32.const 1))
+    (block
+      (br_if 0 (i32.lt_s (local.get 0) (i32.const 2)))
+      (loop
+        (local.set 1 (i32.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i32.add (local.get 0) (i32.const -1)))
+        (br_if 0 (i32.gt_s (local.get 0) (i32.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+
+  (export "" (func 0))
+)`).exports[""](10), 3628800);
diff --git a/js/src/jit-test/tests/wasm/spec/README.md b/js/src/jit-test/tests/wasm/spec/README.md
new file mode 100644
index 0000000000..bc1e89348e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/README.md
@@ -0,0 +1,5 @@
+# Wasm Spec Tests
+
+These tests are autogenerated using a tool, do not edit.
+
+See `jit-test/etc/wasm/` for more information.
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js
new file mode 100644
index 0000000000..cde2d92cef
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/call_indirect.wast.js
@@ -0,0 +1,1240 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/call_indirect.wast
+
+// ./test/core/call_indirect.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definitions
+  (type $$proc (func))
+  (type $$out-i32 (func (result i32)))
+  (type $$out-i64 (func (result i64)))
+  (type $$out-f32 (func (result f32)))
+  (type $$out-f64 (func (result f64)))
+  (type $$out-f64-i32 (func (result f64 i32)))
+  (type $$over-i32 (func (param i32) (result i32)))
+  (type $$over-i64 (func (param i64) (result i64)))
+  (type $$over-f32 (func (param f32) (result f32)))
+  (type $$over-f64 (func (param f64) (result f64)))
+  (type $$over-i32-f64 (func (param i32 f64) (result i32 f64)))
+  (type $$swap-i32-i64 (func (param i32 i64) (result i64 i32)))
+  (type $$f32-i32 (func (param f32 i32) (result i32)))
+  (type $$i32-i64 (func (param i32 i64) (result i64)))
+  (type $$f64-f32 (func (param f64 f32) (result f32)))
+  (type $$i64-f64 (func (param i64 f64) (result f64)))
+  (type $$over-i32-duplicate (func (param i32) (result i32)))
+  (type $$over-i64-duplicate (func (param i64) (result i64)))
+  (type $$over-f32-duplicate (func (param f32) (result f32)))
+  (type $$over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $$const-i32 (type $$out-i32) (i32.const 0x132))
+  (func $$const-i64 (type $$out-i64) (i64.const 0x164))
+  (func $$const-f32 (type $$out-f32) (f32.const 0xf32))
+  (func $$const-f64 (type $$out-f64) (f64.const 0xf64))
+  (func $$const-f64-i32 (type $$out-f64-i32) (f64.const 0xf64) (i32.const 32))
+
+  (func $$id-i32 (type $$over-i32) (local.get 0))
+  (func $$id-i64 (type $$over-i64) (local.get 0))
+  (func $$id-f32 (type $$over-f32) (local.get 0))
+  (func $$id-f64 (type $$over-f64) (local.get 0))
+  (func $$id-i32-f64 (type $$over-i32-f64) (local.get 0) (local.get 1))
+  (func $$swap-i32-i64 (type $$swap-i32-i64) (local.get 1) (local.get 0))
+
+  (func $$i32-i64 (type $$i32-i64) (local.get 1))
+  (func $$i64-f64 (type $$i64-f64) (local.get 1))
+  (func $$f32-i32 (type $$f32-i32) (local.get 1))
+  (func $$f64-f32 (type $$f64-f32) (local.get 1))
+
+  (func $$over-i32-duplicate (type $$over-i32-duplicate) (local.get 0))
+  (func $$over-i64-duplicate (type $$over-i64-duplicate) (local.get 0))
+  (func $$over-f32-duplicate (type $$over-f32-duplicate) (local.get 0))
+  (func $$over-f64-duplicate (type $$over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $$const-i32 $$const-i64 $$const-f32 $$const-f64  ;; 0..3
+      $$id-i32 $$id-i64 $$id-f32 $$id-f64              ;; 4..7
+      $$f32-i32 $$i32-i64 $$f64-f32 $$i64-f64          ;; 9..11
+      $$fac-i64 $$fib-i64 $$even $$odd                 ;; 12..15
+      $$runaway $$mutual-runaway1 $$mutual-runaway2   ;; 16..18
+      $$over-i32-duplicate $$over-i64-duplicate      ;; 19..20
+      $$over-f32-duplicate $$over-f64-duplicate      ;; 21..22
+      $$fac-i32 $$fac-f32 $$fac-f64                   ;; 23..25
+      $$fib-i32 $$fib-f32 $$fib-f64                   ;; 26..28
+      $$const-f64-i32 $$id-i32-f64 $$swap-i32-i64     ;; 29..31
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (call_indirect (i32.const 0))
+    (call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (call_indirect (result) (i32.const 0))
+    (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+    (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+    (drop (i32.eqz
+      (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    ))
+    (drop (i32.eqz
+      (call_indirect
+        (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+        (result) (result i32) (result) (result)
+        (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+      )
+    ))
+    (drop (i64.eqz
+      (call_indirect (type $$over-i64) (param i64) (result i64)
+        (i64.const 0) (i32.const 0)
+      )
+    ))
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (call_indirect (type $$out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (call_indirect (type $$out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (call_indirect (type $$out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (call_indirect (type $$out-f64) (i32.const 3))
+  )
+  (func (export "type-f64-i32") (result f64 i32)
+    (call_indirect (type $$out-f64-i32) (i32.const 29))
+  )
+
+  (func (export "type-index") (result i64)
+    (call_indirect (type $$over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (call_indirect (type $$over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (call_indirect (type $$over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (call_indirect (type $$over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (call_indirect (type $$over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (call_indirect (type $$f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call_indirect (type $$i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call_indirect (type $$f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call_indirect (type $$i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
+  )
+
+  (func (export "type-all-f64-i32") (result f64 i32)
+    (call_indirect (type $$out-f64-i32) (i32.const 29))
+  )
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call_indirect (type $$over-i32-f64)
+      (i32.const 1) (f64.const 2) (i32.const 30)
+    )
+  )
+  (func (export "type-all-i32-i64") (result i64 i32)
+    (call_indirect (type $$swap-i32-i64)
+      (i32.const 1) (i64.const 2) (i32.const 31)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (call_indirect (type $$over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural-i64") (param i32) (result i64)
+    (call_indirect (type $$over-i64-duplicate) (i64.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-i32") (param i32) (result i32)
+    (call_indirect (type $$over-i32-duplicate) (i32.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-f32") (param i32) (result f32)
+    (call_indirect (type $$over-f32-duplicate) (f32.const 9.0) (local.get 0))
+  )
+  (func (export "dispatch-structural-f64") (param i32) (result f64)
+    (call_indirect (type $$over-f64-duplicate) (f64.const 9.0) (local.get 0))
+  )
+
+  ;; Recursion
+
+  (func $$fac-i64 (export "fac-i64") (type $$over-i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 12)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-i64 (export "fib-i64") (type $$over-i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 2))
+            (i32.const 13)
+          )
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 13)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-i32 (export "fac-i32") (type $$over-i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 1))
+      (else
+        (i32.mul
+          (local.get 0)
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-f32 (export "fac-f32") (type $$over-f32)
+    (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.mul
+          (local.get 0)
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 24)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-f64 (export "fac-f64") (type $$over-f64)
+    (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.mul
+          (local.get 0)
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 25)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-i32 (export "fib-i32") (type $$over-i32)
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 2))
+            (i32.const 26)
+          )
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 26)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-f32 (export "fib-f32") (type $$over-f32)
+    (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.add
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 2.0))
+            (i32.const 27)
+          )
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 27)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-f64 (export "fib-f64") (type $$over-f64)
+    (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.add
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 2.0))
+            (i32.const 28)
+          )
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 28)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (call_indirect (type $$over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $$odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (call_indirect (type $$over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $$runaway (export "runaway") (call_indirect (type $$proc) (i32.const 16)))
+
+  (func $$mutual-runaway1 (export "mutual-runaway") (call_indirect (type $$proc) (i32.const 18)))
+  (func $$mutual-runaway2 (call_indirect (type $$proc) (i32.const 17)))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call_indirect (type $$out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i64)
+    (block (result i64) (br_if 0 (call_indirect (type $$out-i64) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0))))
+  )
+
+  (func (export "as-br_table-first") (result f32)
+    (block (result f32) (call_indirect (type $$out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (br_table 0 0))
+  )
+
+  (func (export "as-store-first")
+    (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call_indirect (type $$out-f64) (i32.const 3)) (f64.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+  (func (export "as-return-value") (result i32)
+    (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4)) (return)
+  )
+  (func (export "as-drop-operand")
+    (call_indirect (type $$over-i64) (i64.const 1) (i32.const 5)) (drop)
+  )
+  (func (export "as-br-value") (result f32)
+    (block (result f32) (br 0 (call_indirect (type $$over-f32) (f32.const 1) (i32.const 6))))
+  )
+  (func (export "as-local.set-value") (result f64)
+    (local f64) (local.set 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result f64)
+    (local f64) (local.tee 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7)))
+  )
+  (global $$a (mut f64) (f64.const 10.0))
+  (func (export "as-global.set-value") (result f64)
+    (global.set $$a (call_indirect (type $$over-f64) (f64.const 1.0) (i32.const 7)))
+    (global.get $$a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32)
+      (f32.sqrt
+        (call_indirect (type $$over-f32) (f32.const 0x0p+0) (i32.const 6))
+      )
+    )
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32)
+      (i32.sub
+        (i32.const 10)
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32)
+      (i32.eqz
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (i32.le_u
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (i32.ne
+        (i32.const 10)
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64)
+      (i64.extend_i32_s
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+)`);
+
+// ./test/core/call_indirect.wast:471
+assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:472
+assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:473
+assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:474
+assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]);
+
+// ./test/core/call_indirect.wast:475
+assert_return(() => invoke($0, `type-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:477
+assert_return(() => invoke($0, `type-index`, []), [value("i64", 100n)]);
+
+// ./test/core/call_indirect.wast:479
+assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:480
+assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:481
+assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]);
+
+// ./test/core/call_indirect.wast:482
+assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]);
+
+// ./test/core/call_indirect.wast:484
+assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:485
+assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:486
+assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]);
+
+// ./test/core/call_indirect.wast:487
+assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]);
+
+// ./test/core/call_indirect.wast:489
+assert_return(() => invoke($0, `type-all-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:490
+assert_return(() => invoke($0, `type-all-i32-f64`, []), [value("i32", 1), value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:491
+assert_return(() => invoke($0, `type-all-i32-i64`, []), [value("i64", 2n), value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:493
+assert_return(() => invoke($0, `dispatch`, [5, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:494
+assert_return(() => invoke($0, `dispatch`, [5, 5n]), [value("i64", 5n)]);
+
+// ./test/core/call_indirect.wast:495
+assert_return(() => invoke($0, `dispatch`, [12, 5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:496
+assert_return(() => invoke($0, `dispatch`, [13, 5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:497
+assert_return(() => invoke($0, `dispatch`, [20, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:498
+assert_trap(() => invoke($0, `dispatch`, [0, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:499
+assert_trap(() => invoke($0, `dispatch`, [15, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:500
+assert_trap(() => invoke($0, `dispatch`, [32, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:501
+assert_trap(() => invoke($0, `dispatch`, [-1, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:502
+assert_trap(() => invoke($0, `dispatch`, [1213432423, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:504
+assert_return(() => invoke($0, `dispatch-structural-i64`, [5]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:505
+assert_return(() => invoke($0, `dispatch-structural-i64`, [12]), [value("i64", 362880n)]);
+
+// ./test/core/call_indirect.wast:506
+assert_return(() => invoke($0, `dispatch-structural-i64`, [13]), [value("i64", 55n)]);
+
+// ./test/core/call_indirect.wast:507
+assert_return(() => invoke($0, `dispatch-structural-i64`, [20]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:508
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [11]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:509
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [22]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:511
+assert_return(() => invoke($0, `dispatch-structural-i32`, [4]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:512
+assert_return(() => invoke($0, `dispatch-structural-i32`, [23]), [value("i32", 362880)]);
+
+// ./test/core/call_indirect.wast:513
+assert_return(() => invoke($0, `dispatch-structural-i32`, [26]), [value("i32", 55)]);
+
+// ./test/core/call_indirect.wast:514
+assert_return(() => invoke($0, `dispatch-structural-i32`, [19]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:515
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [9]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:516
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [21]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:518
+assert_return(() => invoke($0, `dispatch-structural-f32`, [6]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:519
+assert_return(() => invoke($0, `dispatch-structural-f32`, [24]), [value("f32", 362880)]);
+
+// ./test/core/call_indirect.wast:520
+assert_return(() => invoke($0, `dispatch-structural-f32`, [27]), [value("f32", 55)]);
+
+// ./test/core/call_indirect.wast:521
+assert_return(() => invoke($0, `dispatch-structural-f32`, [21]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:522
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [8]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:523
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [19]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:525
+assert_return(() => invoke($0, `dispatch-structural-f64`, [7]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:526
+assert_return(() => invoke($0, `dispatch-structural-f64`, [25]), [value("f64", 362880)]);
+
+// ./test/core/call_indirect.wast:527
+assert_return(() => invoke($0, `dispatch-structural-f64`, [28]), [value("f64", 55)]);
+
+// ./test/core/call_indirect.wast:528
+assert_return(() => invoke($0, `dispatch-structural-f64`, [22]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:529
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [10]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:530
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [18]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:532
+assert_return(() => invoke($0, `fac-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:533
+assert_return(() => invoke($0, `fac-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:534
+assert_return(() => invoke($0, `fac-i64`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:535
+assert_return(() => invoke($0, `fac-i64`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/call_indirect.wast:537
+assert_return(() => invoke($0, `fac-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:538
+assert_return(() => invoke($0, `fac-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:539
+assert_return(() => invoke($0, `fac-i32`, [5]), [value("i32", 120)]);
+
+// ./test/core/call_indirect.wast:540
+assert_return(() => invoke($0, `fac-i32`, [10]), [value("i32", 3628800)]);
+
+// ./test/core/call_indirect.wast:542
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:543
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:544
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 5)]), [value("f32", 120)]);
+
+// ./test/core/call_indirect.wast:545
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 10)]), [value("f32", 3628800)]);
+
+// ./test/core/call_indirect.wast:547
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:548
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:549
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 5)]), [value("f64", 120)]);
+
+// ./test/core/call_indirect.wast:550
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 10)]), [value("f64", 3628800)]);
+
+// ./test/core/call_indirect.wast:552
+assert_return(() => invoke($0, `fib-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:553
+assert_return(() => invoke($0, `fib-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:554
+assert_return(() => invoke($0, `fib-i64`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:555
+assert_return(() => invoke($0, `fib-i64`, [5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:556
+assert_return(() => invoke($0, `fib-i64`, [20n]), [value("i64", 10946n)]);
+
+// ./test/core/call_indirect.wast:558
+assert_return(() => invoke($0, `fib-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:559
+assert_return(() => invoke($0, `fib-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:560
+assert_return(() => invoke($0, `fib-i32`, [2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:561
+assert_return(() => invoke($0, `fib-i32`, [5]), [value("i32", 8)]);
+
+// ./test/core/call_indirect.wast:562
+assert_return(() => invoke($0, `fib-i32`, [20]), [value("i32", 10946)]);
+
+// ./test/core/call_indirect.wast:564
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:565
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:566
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 2)]), [value("f32", 2)]);
+
+// ./test/core/call_indirect.wast:567
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 5)]), [value("f32", 8)]);
+
+// ./test/core/call_indirect.wast:568
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 20)]), [value("f32", 10946)]);
+
+// ./test/core/call_indirect.wast:570
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:571
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:572
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 2)]), [value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:573
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 5)]), [value("f64", 8)]);
+
+// ./test/core/call_indirect.wast:574
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 20)]), [value("f64", 10946)]);
+
+// ./test/core/call_indirect.wast:576
+assert_return(() => invoke($0, `even`, [0]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:577
+assert_return(() => invoke($0, `even`, [1]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:578
+assert_return(() => invoke($0, `even`, [100]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:579
+assert_return(() => invoke($0, `even`, [77]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:580
+assert_return(() => invoke($0, `odd`, [0]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:581
+assert_return(() => invoke($0, `odd`, [1]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:582
+assert_return(() => invoke($0, `odd`, [200]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:583
+assert_return(() => invoke($0, `odd`, [77]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:585
+assert_exhaustion(() => invoke($0, `runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:586
+assert_exhaustion(() => invoke($0, `mutual-runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:588
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:589
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:590
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:592
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:594
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:595
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:597
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:598
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:600
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/call_indirect.wast:601
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/call_indirect.wast:603
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:604
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:605
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/call_indirect.wast:606
+assert_return(() => invoke($0, `as-br-value`, []), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:607
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:608
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:609
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:610
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:612
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 0)]);
+
+// ./test/core/call_indirect.wast:613
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 11)]);
+
+// ./test/core/call_indirect.wast:614
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:615
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:616
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:617
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:618
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:623
+let $1 = instantiate(`(module
+  (type $$ii-i (func (param i32 i32) (result i32)))
+
+  (table $$t1 funcref (elem $$f $$g))
+  (table $$t2 funcref (elem $$h $$i $$j))
+  (table $$t3 4 funcref)
+  (elem (table $$t3) (i32.const 0) func $$g $$h)
+  (elem (table $$t3) (i32.const 3) func $$z)
+
+  (func $$f (type $$ii-i) (i32.add (local.get 0) (local.get 1)))
+  (func $$g (type $$ii-i) (i32.sub (local.get 0) (local.get 1)))
+  (func $$h (type $$ii-i) (i32.mul (local.get 0) (local.get 1)))
+  (func $$i (type $$ii-i) (i32.div_u (local.get 0) (local.get 1)))
+  (func $$j (type $$ii-i) (i32.rem_u (local.get 0) (local.get 1)))
+  (func $$z)
+
+  (func (export "call-1") (param i32 i32 i32) (result i32)
+    (call_indirect $$t1 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-2") (param i32 i32 i32) (result i32)
+    (call_indirect $$t2 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-3") (param i32 i32 i32) (result i32)
+    (call_indirect $$t3 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+)`);
+
+// ./test/core/call_indirect.wast:650
+assert_return(() => invoke($1, `call-1`, [2, 3, 0]), [value("i32", 5)]);
+
+// ./test/core/call_indirect.wast:651
+assert_return(() => invoke($1, `call-1`, [2, 3, 1]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:652
+assert_trap(() => invoke($1, `call-1`, [2, 3, 2]), `undefined element`);
+
+// ./test/core/call_indirect.wast:654
+assert_return(() => invoke($1, `call-2`, [2, 3, 0]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:655
+assert_return(() => invoke($1, `call-2`, [2, 3, 1]), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:656
+assert_return(() => invoke($1, `call-2`, [2, 3, 2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:657
+assert_trap(() => invoke($1, `call-2`, [2, 3, 3]), `undefined element`);
+
+// ./test/core/call_indirect.wast:659
+assert_return(() => invoke($1, `call-3`, [2, 3, 0]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:660
+assert_return(() => invoke($1, `call-3`, [2, 3, 1]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:661
+assert_trap(() => invoke($1, `call-3`, [2, 3, 2]), `uninitialized element`);
+
+// ./test/core/call_indirect.wast:662
+assert_trap(() => invoke($1, `call-3`, [2, 3, 3]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:663
+assert_trap(() => invoke($1, `call-3`, [2, 3, 4]), `undefined element`);
+
+// ./test/core/call_indirect.wast:668
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (param i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:680
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (param i32) (type $$sig) (result i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:692
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (param i32) (result i32) (type $$sig)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:704
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (result i32) (type $$sig) (param i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:716
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (result i32) (param i32) (type $$sig)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:728
+assert_malformed(
+  () => instantiate(`(table 0 funcref) (func (result i32)   (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:738
+assert_malformed(
+  () => instantiate(`(table 0 funcref) (func (call_indirect (param $$x i32) (i32.const 0) (i32.const 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:745
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:755
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:765
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func   (call_indirect (type $$sig) (param i32) (i32.const 0) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:775
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (param i32) (result i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:790
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (func $$no-table (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `unknown table`,
+);
+
+// ./test/core/call_indirect.wast:798
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:806
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $$type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:815
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:823
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $$arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:831
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:839
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$arity-2-vs-0
+      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:850
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:858
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:867
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $$type-first-void-vs-num
+      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:877
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $$type-second-void-vs-num
+      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:887
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $$type-first-num-vs-num
+      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:897
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $$type-second-num-vs-num
+      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:908
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-block
+      (block
+        (call_indirect (type $$sig) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:921
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-block
+      (block
+        (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:934
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-loop
+      (loop
+        (call_indirect (type $$sig) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:947
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-loop
+      (loop
+        (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:960
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $$sig) (i32.const 0))
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:976
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:996
+assert_invalid(
+  () => instantiate(`(module
+    (table 0 funcref)
+    (func $$unbound-type (call_indirect (type 1) (i32.const 0)))
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1003
+assert_invalid(
+  () => instantiate(`(module
+    (table 0 funcref)
+    (func $$large-type (call_indirect (type 1012321300) (i32.const 0)))
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1014
+assert_invalid(
+  () => instantiate(`(module (table funcref (elem 0 0)))`),
+  `unknown function`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js
new file mode 100644
index 0000000000..747db66dec
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/custom.wast.js
@@ -0,0 +1,157 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/custom.wast
+
+// ./test/core/custom.wast:1
+let $0 = instantiate(`(module binary
+  "\\00asm" "\\01\\00\\00\\00"
+  "\\00\\24\\10" "a custom section" "this is the payload"
+  "\\00\\20\\10" "a custom section" "this is payload"
+  "\\00\\11\\10" "a custom section" ""
+  "\\00\\10\\00" "" "this is payload"
+  "\\00\\01\\00" "" ""
+  "\\00\\24\\10" "\\00\\00custom sectio\\00" "this is the payload"
+  "\\00\\24\\10" "\\ef\\bb\\bfa custom sect" "this is the payload"
+  "\\00\\24\\10" "a custom sect\\e2\\8c\\a3" "this is the payload"
+  "\\00\\1f\\16" "module within a module" "\\00asm" "\\01\\00\\00\\00"
+)`);
+
+// ./test/core/custom.wast:14
+let $1 = instantiate(`(module binary
+  "\\00asm" "\\01\\00\\00\\00"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\01\\01\\00"  ;; type section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\02\\01\\00"  ;; import section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\03\\01\\00"  ;; function section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\04\\01\\00"  ;; table section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\05\\01\\00"  ;; memory section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\06\\01\\00"  ;; global section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\07\\01\\00"  ;; export section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\09\\01\\00"  ;; element section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\0a\\01\\00"  ;; code section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\0b\\01\\00"  ;; data section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+)`);
+
+// ./test/core/custom.wast:50
+let $2 = instantiate(`(module binary
+  "\\00asm" "\\01\\00\\00\\00"
+  "\\01\\07\\01\\60\\02\\7f\\7f\\01\\7f"                ;; type section
+  "\\00\\1a\\06" "custom" "this is the payload"   ;; custom section
+  "\\03\\02\\01\\00"                               ;; function section
+  "\\07\\0a\\01\\06\\61\\64\\64\\54\\77\\6f\\00\\00"       ;; export section
+  "\\0a\\09\\01\\07\\00\\20\\00\\20\\01\\6a\\0b"          ;; code section
+  "\\00\\1b\\07" "custom2" "this is the payload"  ;; custom section
+)`);
+
+// ./test/core/custom.wast:60
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:68
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\00"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:76
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\00\\00\\05\\01\\00\\07\\00\\00"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:84
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\26\\10" "a custom section" "this is the payload"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:92
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\25\\10" "a custom section" "this is the payload"
+    "\\00\\24\\10" "a custom section" "this is the payload"
+  )`),
+  `malformed section id`,
+);
+
+// ./test/core/custom.wast:101
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\01\\07\\01\\60\\02\\7f\\7f\\01\\7f"                         ;; type section
+    "\\00\\25\\10" "a custom section" "this is the payload"  ;; wrong length!
+    "\\03\\02\\01\\00"                                        ;; function section
+    "\\0a\\09\\01\\07\\00\\20\\00\\20\\01\\6a\\0b"                   ;; code section
+    "\\00\\1b\\07" "custom2" "this is the payload"           ;; custom section
+  )`),
+  `function and code section have inconsistent lengths`,
+);
+
+// ./test/core/custom.wast:114
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm\\01\\00\\00\\00"
+    "\\00asm\\01\\00\\00\\00"
+  )`),
+  `length out of bounds`,
+);
+
+// ./test/core/custom.wast:122
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\05\\03\\01\\00\\01"                         ;; memory section
+    "\\0c\\01\\02"                               ;; data count section (2 segments)
+    "\\0b\\06\\01\\00\\41\\00\\0b\\00"                ;; data section (1 segment)
+  )`),
+  `data count and data section have inconsistent lengths`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt b/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt
new file mode 100644
index 0000000000..82c2a20004
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; --wasm-exceptions; skip-if: !wasmExceptionsEnabled()
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/harness/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: 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",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js
new file mode 100644
index 0000000000..a995b8dc37
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/rethrow.wast.js
@@ -0,0 +1,140 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/rethrow.wast
+
+// ./test/core/rethrow.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0)
+  (tag $$e1)
+
+  (func (export "catch-rethrow-0")
+    (try
+      (do (throw $$e0))
+      (catch $$e0 (rethrow 0))
+    )
+  )
+
+  (func (export "catch-rethrow-1") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e0))
+      (catch $$e0
+        (if (i32.eqz (local.get 0)) (then (rethrow 1))) (i32.const 23)
+      )
+    )
+  )
+
+  (func (export "catchall-rethrow-0")
+    (try
+      (do (throw $$e0))
+      (catch_all (rethrow 0))
+    )
+  )
+
+  (func (export "catchall-rethrow-1") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e0))
+      (catch_all
+        (if (i32.eqz (local.get 0)) (then (rethrow 1))) (i32.const 23)
+      )
+    )
+  )
+
+  (func (export "rethrow-nested") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e1))
+      (catch $$e1
+        (try (result i32)
+          (do (throw $$e0))
+          (catch $$e0
+            (if (i32.eq (local.get 0) (i32.const 0)) (then (rethrow 1)))
+            (if (i32.eq (local.get 0) (i32.const 1)) (then (rethrow 2)))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "rethrow-recatch") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $$e0))
+      (catch $$e0
+        (try (result i32)
+         (do (if (i32.eqz (local.get 0)) (then (rethrow 2))) (i32.const 42))
+         (catch $$e0 (i32.const 23))
+        )
+      )
+    )
+  )
+
+  (func (export "rethrow-stack-polymorphism")
+    (try
+      (do (throw $$e0))
+      (catch $$e0 (i32.const 1) (rethrow 0))
+    )
+  )
+)`);
+
+// ./test/core/rethrow.wast:75
+assert_exception(() => invoke($0, `catch-rethrow-0`, []));
+
+// ./test/core/rethrow.wast:77
+assert_exception(() => invoke($0, `catch-rethrow-1`, [0]));
+
+// ./test/core/rethrow.wast:78
+assert_return(() => invoke($0, `catch-rethrow-1`, [1]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:80
+assert_exception(() => invoke($0, `catchall-rethrow-0`, []));
+
+// ./test/core/rethrow.wast:82
+assert_exception(() => invoke($0, `catchall-rethrow-1`, [0]));
+
+// ./test/core/rethrow.wast:83
+assert_return(() => invoke($0, `catchall-rethrow-1`, [1]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:84
+assert_exception(() => invoke($0, `rethrow-nested`, [0]));
+
+// ./test/core/rethrow.wast:85
+assert_exception(() => invoke($0, `rethrow-nested`, [1]));
+
+// ./test/core/rethrow.wast:86
+assert_return(() => invoke($0, `rethrow-nested`, [2]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:88
+assert_return(() => invoke($0, `rethrow-recatch`, [0]), [value("i32", 23)]);
+
+// ./test/core/rethrow.wast:89
+assert_return(() => invoke($0, `rethrow-recatch`, [1]), [value("i32", 42)]);
+
+// ./test/core/rethrow.wast:91
+assert_exception(() => invoke($0, `rethrow-stack-polymorphism`, []));
+
+// ./test/core/rethrow.wast:93
+assert_invalid(() => instantiate(`(module (func (rethrow 0)))`), `invalid rethrow label`);
+
+// ./test/core/rethrow.wast:94
+assert_invalid(
+  () => instantiate(`(module (func (block (rethrow 0))))`),
+  `invalid rethrow label`,
+);
+
+// ./test/core/rethrow.wast:95
+assert_invalid(
+  () => instantiate(`(module (func (try (do (rethrow 0)) (delegate 0))))`),
+  `invalid rethrow label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js
new file mode 100644
index 0000000000..9381e67fc5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_fill.wast.js
@@ -0,0 +1,234 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_fill.wast
+
+// ./test/core/table_fill.wast:1
+let $0 = instantiate(`(module
+  (table $$t 10 externref)
+
+  (func (export "fill") (param $$i i32) (param $$r externref) (param $$n i32)
+    (table.fill $$t (local.get $$i) (local.get $$r) (local.get $$n))
+  )
+
+  (func (export "get") (param $$i i32) (result externref)
+    (table.get $$t (local.get $$i))
+  )
+)`);
+
+// ./test/core/table_fill.wast:13
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:14
+assert_return(() => invoke($0, `get`, [2]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:15
+assert_return(() => invoke($0, `get`, [3]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:16
+assert_return(() => invoke($0, `get`, [4]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:17
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:19
+assert_return(() => invoke($0, `fill`, [2, externref(1), 3]), []);
+
+// ./test/core/table_fill.wast:20
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:21
+assert_return(() => invoke($0, `get`, [2]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:22
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:23
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:24
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:26
+assert_return(() => invoke($0, `fill`, [4, externref(2), 2]), []);
+
+// ./test/core/table_fill.wast:27
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:28
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:29
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:30
+assert_return(() => invoke($0, `get`, [6]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:32
+assert_return(() => invoke($0, `fill`, [4, externref(3), 0]), []);
+
+// ./test/core/table_fill.wast:33
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:34
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:35
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:37
+assert_return(() => invoke($0, `fill`, [8, externref(4), 2]), []);
+
+// ./test/core/table_fill.wast:38
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:39
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:40
+assert_return(() => invoke($0, `get`, [9]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:42
+assert_return(() => invoke($0, `fill`, [9, null, 1]), []);
+
+// ./test/core/table_fill.wast:43
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:44
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:46
+assert_return(() => invoke($0, `fill`, [10, externref(5), 0]), []);
+
+// ./test/core/table_fill.wast:47
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:49
+assert_trap(() => invoke($0, `fill`, [8, externref(6), 3]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:53
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:54
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:55
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:57
+assert_trap(() => invoke($0, `fill`, [11, null, 0]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:62
+assert_trap(() => invoke($0, `fill`, [11, null, 10]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:70
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-value-length-empty-vs-i32-i32
+      (table.fill $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:79
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32
+      (table.fill $$t (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:88
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-value-empty-vs
+      (table.fill $$t (i32.const 1) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:97
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-length-empty-vs-i32
+      (table.fill $$t (i32.const 1) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:106
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-index-f32-vs-i32
+      (table.fill $$t (f32.const 1) (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:115
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 funcref)
+    (func $$type-value-vs-funcref (param $$r externref)
+      (table.fill $$t (i32.const 1) (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:124
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-length-f32-vs-i32
+      (table.fill $$t (i32.const 1) (ref.null extern) (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:134
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 externref)
+    (table $$t2 1 funcref)
+    (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+      (table.fill $$t2 (i32.const 0) (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:145
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-empty-vs-num (result i32)
+      (table.fill $$t (i32.const 0) (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js
new file mode 100644
index 0000000000..f4982cde3a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_get.wast.js
@@ -0,0 +1,126 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_get.wast
+
+// ./test/core/table_get.wast:1
+let $0 = instantiate(`(module
+  (table $$t2 2 externref)
+  (table $$t3 3 funcref)
+  (elem (table $$t3) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "init") (param $$r externref)
+    (table.set $$t2 (i32.const 1) (local.get $$r))
+    (table.set $$t3 (i32.const 2) (table.get $$t3 (i32.const 1)))
+  )
+
+  (func (export "get-externref") (param $$i i32) (result externref)
+    (table.get $$t2 (local.get $$i))
+  )
+  (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+    (table.get $$t3 (local.get $$i))
+  )
+
+  (func (export "is_null-funcref") (param $$i i32) (result i32)
+    (ref.is_null (call $$f3 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/table_get.wast:24
+invoke($0, `init`, [externref(1)]);
+
+// ./test/core/table_get.wast:26
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_get.wast:27
+assert_return(() => invoke($0, `get-externref`, [1]), [value('externref', externref(1))]);
+
+// ./test/core/table_get.wast:29
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_get.wast:30
+assert_return(() => invoke($0, `is_null-funcref`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:31
+assert_return(() => invoke($0, `is_null-funcref`, [2]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:33
+assert_trap(() => invoke($0, `get-externref`, [2]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:34
+assert_trap(() => invoke($0, `get-funcref`, [3]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:35
+assert_trap(() => invoke($0, `get-externref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:36
+assert_trap(() => invoke($0, `get-funcref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:41
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32 (result externref)
+      (table.get $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:50
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-f32-vs-i32 (result externref)
+      (table.get $$t (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:60
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-externref-vs-empty
+      (table.get $$t (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:69
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-externref-vs-funcref (result funcref)
+      (table.get $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:79
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 funcref)
+    (table $$t2 1 externref)
+    (func $$type-result-externref-vs-funcref-multi (result funcref)
+      (table.get $$t2 (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js
new file mode 100644
index 0000000000..f299984d66
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_grow.wast.js
@@ -0,0 +1,268 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_grow.wast
+
+// ./test/core/table_grow.wast:1
+let $0 = instantiate(`(module
+  (table $$t 0 externref)
+
+  (func (export "get") (param $$i i32) (result externref) (table.get $$t (local.get $$i)))
+  (func (export "set") (param $$i i32) (param $$r externref) (table.set $$t (local.get $$i) (local.get $$r)))
+
+  (func (export "grow") (param $$sz i32) (param $$init externref) (result i32)
+    (table.grow $$t (local.get $$init) (local.get $$sz))
+  )
+  (func (export "size") (result i32) (table.size $$t))
+)`);
+
+// ./test/core/table_grow.wast:13
+assert_return(() => invoke($0, `size`, []), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:14
+assert_trap(() => invoke($0, `set`, [0, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:15
+assert_trap(() => invoke($0, `get`, [0]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:17
+assert_return(() => invoke($0, `grow`, [1, null]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:18
+assert_return(() => invoke($0, `size`, []), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:19
+assert_return(() => invoke($0, `get`, [0]), [value('externref', null)]);
+
+// ./test/core/table_grow.wast:20
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:21
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:22
+assert_trap(() => invoke($0, `set`, [1, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:23
+assert_trap(() => invoke($0, `get`, [1]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:25
+assert_return(() => invoke($0, `grow`, [4, externref(3)]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:26
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/table_grow.wast:27
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:28
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:29
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:30
+assert_return(() => invoke($0, `get`, [1]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:31
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:32
+assert_return(() => invoke($0, `set`, [4, externref(4)]), []);
+
+// ./test/core/table_grow.wast:33
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(4))]);
+
+// ./test/core/table_grow.wast:34
+assert_trap(() => invoke($0, `set`, [5, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:35
+assert_trap(() => invoke($0, `get`, [5]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:39
+let $1 = instantiate(`(module
+  (table $$t 0x10 funcref)
+  (elem declare func $$f)
+  (func $$f (export "grow") (result i32)
+    (table.grow $$t (ref.func $$f) (i32.const 0xffff_fff0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:47
+assert_return(() => invoke($1, `grow`, []), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:50
+let $2 = instantiate(`(module
+  (table $$t 0 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null extern) (local.get 0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:57
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:58
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:59
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:60
+assert_return(() => invoke($2, `grow`, [2]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:61
+assert_return(() => invoke($2, `grow`, [800]), [value("i32", 3)]);
+
+// ./test/core/table_grow.wast:64
+let $3 = instantiate(`(module
+  (table $$t 0 10 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null extern) (local.get 0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:71
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:72
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:73
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:74
+assert_return(() => invoke($3, `grow`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_grow.wast:75
+assert_return(() => invoke($3, `grow`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_grow.wast:76
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:77
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:78
+assert_return(() => invoke($3, `grow`, [65536]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:81
+let $4 = instantiate(`(module
+  (table $$t 10 funcref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null func) (local.get 0))
+  )
+  (elem declare func 1)
+  (func (export "check-table-null") (param i32 i32) (result funcref)
+    (local funcref)
+    (local.set 2 (ref.func 1))
+    (block
+      (loop
+        (local.set 2 (table.get $$t (local.get 0)))
+        (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)`);
+
+// ./test/core/table_grow.wast:103
+assert_return(() => invoke($4, `check-table-null`, [0, 9]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:104
+assert_return(() => invoke($4, `grow`, [10]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:105
+assert_return(() => invoke($4, `check-table-null`, [0, 19]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:110
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-init-size-empty-vs-i32-externref (result i32)
+      (table.grow $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:119
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-size-empty-vs-i32 (result i32)
+      (table.grow $$t (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:128
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-init-empty-vs-externref (result i32)
+      (table.grow $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:137
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-size-f32-vs-i32 (result i32)
+      (table.grow $$t (ref.null extern) (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:146
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 funcref)
+    (func $$type-init-externref-vs-funcref (param $$r externref) (result i32)
+      (table.grow $$t (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:156
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-empty
+      (table.grow $$t (ref.null extern) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:165
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (table.grow $$t (ref.null extern) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js
new file mode 100644
index 0000000000..b44fcfc002
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_set.wast.js
@@ -0,0 +1,177 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_set.wast
+
+// ./test/core/table_set.wast:1
+let $0 = instantiate(`(module
+  (table $$t2 1 externref)
+  (table $$t3 2 funcref)
+  (elem (table $$t3) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "get-externref") (param $$i i32) (result externref)
+    (table.get $$t2 (local.get $$i))
+  )
+  (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+    (table.get $$t3 (local.get $$i))
+  )
+
+  (func (export "set-externref") (param $$i i32) (param $$r externref)
+    (table.set $$t2 (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))
+  )
+  (func (export "set-funcref-from") (param $$i i32) (param $$j i32)
+    (table.set $$t3 (local.get $$i) (table.get $$t3 (local.get $$j)))
+  )
+
+  (func (export "is_null-funcref") (param $$i i32) (result i32)
+    (ref.is_null (call $$f3 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/table_set.wast:29
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:30
+assert_return(() => invoke($0, `set-externref`, [0, externref(1)]), []);
+
+// ./test/core/table_set.wast:31
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', externref(1))]);
+
+// ./test/core/table_set.wast:32
+assert_return(() => invoke($0, `set-externref`, [0, null]), []);
+
+// ./test/core/table_set.wast:33
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:35
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:36
+assert_return(() => invoke($0, `set-funcref-from`, [0, 1]), []);
+
+// ./test/core/table_set.wast:37
+assert_return(() => invoke($0, `is_null-funcref`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_set.wast:38
+assert_return(() => invoke($0, `set-funcref`, [0, null]), []);
+
+// ./test/core/table_set.wast:39
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:41
+assert_trap(() => invoke($0, `set-externref`, [2, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:42
+assert_trap(() => invoke($0, `set-funcref`, [3, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:43
+assert_trap(() => invoke($0, `set-externref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:44
+assert_trap(() => invoke($0, `set-funcref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:46
+assert_trap(() => invoke($0, `set-externref`, [2, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:47
+assert_trap(() => invoke($0, `set-funcref-from`, [3, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:48
+assert_trap(() => invoke($0, `set-externref`, [-1, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:49
+assert_trap(() => invoke($0, `set-funcref-from`, [-1, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:54
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-value-empty-vs-i32-externref
+      (table.set $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:63
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32
+      (table.set $$t (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:72
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-value-empty-vs-externref
+      (table.set $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:81
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-size-f32-vs-i32
+      (table.set $$t (f32.const 1) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:90
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 funcref)
+    (func $$type-value-externref-vs-funcref (param $$r externref)
+      (table.set $$t (i32.const 1) (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:100
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 externref)
+    (table $$t2 1 funcref)
+    (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+      (table.set $$t2 (i32.const 0) (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:111
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-empty-vs-num (result i32)
+      (table.set $$t (i32.const 0) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js
new file mode 100644
index 0000000000..1a574c2ba9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/table_size.wast.js
@@ -0,0 +1,172 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_size.wast
+
+// ./test/core/table_size.wast:1
+let $0 = instantiate(`(module
+  (table $$t0 0 externref)
+  (table $$t1 1 externref)
+  (table $$t2 0 2 externref)
+  (table $$t3 3 8 externref)
+
+  (func (export "size-t0") (result i32) (table.size $$t0))
+  (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))
+
+  (func (export "grow-t0") (param $$sz i32)
+    (drop (table.grow $$t0 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t1") (param $$sz i32)
+    (drop (table.grow $$t1 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t2") (param $$sz i32)
+    (drop (table.grow $$t2 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t3") (param $$sz i32)
+    (drop (table.grow $$t3 (ref.null extern) (local.get $$sz)))
+  )
+)`);
+
+// ./test/core/table_size.wast:26
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:27
+assert_return(() => invoke($0, `grow-t0`, [1]), []);
+
+// ./test/core/table_size.wast:28
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:29
+assert_return(() => invoke($0, `grow-t0`, [4]), []);
+
+// ./test/core/table_size.wast:30
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:31
+assert_return(() => invoke($0, `grow-t0`, [0]), []);
+
+// ./test/core/table_size.wast:32
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:34
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:35
+assert_return(() => invoke($0, `grow-t1`, [1]), []);
+
+// ./test/core/table_size.wast:36
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:37
+assert_return(() => invoke($0, `grow-t1`, [4]), []);
+
+// ./test/core/table_size.wast:38
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:39
+assert_return(() => invoke($0, `grow-t1`, [0]), []);
+
+// ./test/core/table_size.wast:40
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:42
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:43
+assert_return(() => invoke($0, `grow-t2`, [3]), []);
+
+// ./test/core/table_size.wast:44
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:45
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:46
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:47
+assert_return(() => invoke($0, `grow-t2`, [0]), []);
+
+// ./test/core/table_size.wast:48
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:49
+assert_return(() => invoke($0, `grow-t2`, [4]), []);
+
+// ./test/core/table_size.wast:50
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:51
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:52
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:54
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 3)]);
+
+// ./test/core/table_size.wast:55
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:56
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 4)]);
+
+// ./test/core/table_size.wast:57
+assert_return(() => invoke($0, `grow-t3`, [3]), []);
+
+// ./test/core/table_size.wast:58
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:59
+assert_return(() => invoke($0, `grow-t3`, [0]), []);
+
+// ./test/core/table_size.wast:60
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:61
+assert_return(() => invoke($0, `grow-t3`, [2]), []);
+
+// ./test/core/table_size.wast:62
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:63
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:64
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 8)]);
+
+// ./test/core/table_size.wast:69
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-empty
+      (table.size $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_size.wast:78
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (table.size $$t)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js
new file mode 100644
index 0000000000..70e75a12d1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/tag.wast.js
@@ -0,0 +1,40 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/tag.wast
+
+// ./test/core/tag.wast:3
+let $0 = instantiate(`(module
+  (tag)
+  (tag (param i32))
+  (tag (export "t2") (param i32))
+  (tag $$t3 (param i32 f32))
+  (export "t3" (tag 3))
+)`);
+
+// ./test/core/tag.wast:11
+register($0, `test`);
+
+// ./test/core/tag.wast:13
+let $1 = instantiate(`(module
+  (tag $$t0 (import "test" "t2") (param i32))
+  (import "test" "t3" (tag $$t1 (param i32 f32)))
+)`);
+
+// ./test/core/tag.wast:18
+assert_invalid(
+  () => instantiate(`(module (tag (result i32)))`),
+  `non-empty tag result type`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js
new file mode 100644
index 0000000000..cb0baf0d4c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/throw.wast.js
@@ -0,0 +1,87 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/throw.wast
+
+// ./test/core/throw.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0)
+  (tag $$e-i32 (param i32))
+  (tag $$e-f32 (param f32))
+  (tag $$e-i64 (param i64))
+  (tag $$e-f64 (param f64))
+  (tag $$e-i32-i32 (param i32 i32))
+
+  (func $$throw-if (export "throw-if") (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $$e0)))
+    (i32.const 0)
+  )
+
+  (func (export "throw-param-f32") (param f32) (local.get 0) (throw $$e-f32))
+
+  (func (export "throw-param-i64") (param i64) (local.get 0) (throw $$e-i64))
+
+  (func (export "throw-param-f64") (param f64) (local.get 0) (throw $$e-f64))
+
+  (func $$throw-1-2 (i32.const 1) (i32.const 2) (throw $$e-i32-i32))
+  (func (export "test-throw-1-2")
+    (try
+      (do (call $$throw-1-2))
+      (catch $$e-i32-i32
+        (i32.const 2)
+        (if (i32.ne) (then (unreachable)))
+        (i32.const 1)
+        (if (i32.ne) (then (unreachable)))
+      )
+    )
+  )
+)`);
+
+// ./test/core/throw.wast:37
+assert_return(() => invoke($0, `throw-if`, [0]), [value("i32", 0)]);
+
+// ./test/core/throw.wast:38
+assert_exception(() => invoke($0, `throw-if`, [10]));
+
+// ./test/core/throw.wast:39
+assert_exception(() => invoke($0, `throw-if`, [-1]));
+
+// ./test/core/throw.wast:41
+assert_exception(() => invoke($0, `throw-param-f32`, [value("f32", 5)]));
+
+// ./test/core/throw.wast:42
+assert_exception(() => invoke($0, `throw-param-i64`, [5n]));
+
+// ./test/core/throw.wast:43
+assert_exception(() => invoke($0, `throw-param-f64`, [value("f64", 5)]));
+
+// ./test/core/throw.wast:45
+assert_return(() => invoke($0, `test-throw-1-2`, []), []);
+
+// ./test/core/throw.wast:47
+assert_invalid(() => instantiate(`(module (func (throw 0)))`), `unknown tag 0`);
+
+// ./test/core/throw.wast:48
+assert_invalid(
+  () => instantiate(`(module (tag (param i32)) (func (throw 0)))`),
+  `type mismatch: instruction requires [i32] but stack has []`,
+);
+
+// ./test/core/throw.wast:50
+assert_invalid(
+  () => instantiate(`(module (tag (param i32)) (func (i64.const 5) (throw 0)))`),
+  `type mismatch: instruction requires [i32] but stack has [i64]`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js
new file mode 100644
index 0000000000..ab67fc936c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/try_catch.wast.js
@@ -0,0 +1,318 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/try_catch.wast
+
+// ./test/core/try_catch.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0 (export "e0"))
+  (func (export "throw") (throw $$e0))
+)`);
+
+// ./test/core/try_catch.wast:8
+register($0, `test`);
+
+// ./test/core/try_catch.wast:10
+let $1 = instantiate(`(module
+  (tag $$imported-e0 (import "test" "e0"))
+  (func $$imported-throw (import "test" "throw"))
+  (tag $$e0)
+  (tag $$e1)
+  (tag $$e2)
+  (tag $$e-i32 (param i32))
+  (tag $$e-f32 (param f32))
+  (tag $$e-i64 (param i64))
+  (tag $$e-f64 (param f64))
+
+  (func $$throw-if (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $$e0)))
+    (i32.const 0)
+  )
+
+  (func (export "empty-catch") (try (do) (catch $$e0)))
+
+  (func (export "simple-throw-catch") (param i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (i32.eqz) (if (then (throw $$e0)) (else)) (i32.const 42))
+      (catch $$e0 (i32.const 23))
+    )
+  )
+
+  (func (export "unreachable-not-caught") (try (do (unreachable)) (catch_all)))
+
+  (func $$div (param i32 i32) (result i32)
+    (local.get 0) (local.get 1) (i32.div_u)
+  )
+  (func (export "trap-in-callee") (param i32 i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (local.get 1) (call $$div))
+      (catch_all (i32.const 11))
+    )
+  )
+
+  (func (export "catch-complex-1") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do
+            (local.get 0)
+            (i32.eqz)
+            (if
+              (then (throw $$e0))
+              (else
+                (local.get 0)
+                (i32.const 1)
+                (i32.eq)
+                (if (then (throw $$e1)) (else (throw $$e2)))
+              )
+            )
+            (i32.const 2)
+          )
+          (catch $$e0 (i32.const 3))
+        )
+      )
+      (catch $$e1 (i32.const 4))
+    )
+  )
+
+  (func (export "catch-complex-2") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (local.get 0)
+        (i32.eqz)
+        (if
+          (then (throw $$e0))
+          (else
+            (local.get 0)
+            (i32.const 1)
+            (i32.eq)
+            (if (then (throw $$e1)) (else (throw $$e2)))
+          )
+        )
+        (i32.const 2)
+      )
+      (catch $$e0 (i32.const 3))
+      (catch $$e1 (i32.const 4))
+    )
+  )
+
+  (func (export "throw-catch-param-i32") (param i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (throw $$e-i32) (i32.const 2))
+      (catch $$e-i32 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-f32") (param f32) (result f32)
+    (try (result f32)
+      (do (local.get 0) (throw $$e-f32) (f32.const 0))
+      (catch $$e-f32 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-i64") (param i64) (result i64)
+    (try (result i64)
+      (do (local.get 0) (throw $$e-i64) (i64.const 2))
+      (catch $$e-i64 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-f64") (param f64) (result f64)
+    (try (result f64)
+      (do (local.get 0) (throw $$e-f64) (f64.const 0))
+      (catch $$e-f64 (return))
+    )
+  )
+
+  (func $$throw-param-i32 (param i32) (local.get 0) (throw $$e-i32))
+  (func (export "catch-param-i32") (param i32) (result i32)
+    (try (result i32)
+      (do (i32.const 0) (local.get 0) (call $$throw-param-i32))
+      (catch $$e-i32)
+    )
+  )
+
+  (func (export "catch-imported") (result i32)
+    (try (result i32)
+      (do
+        (i32.const 1)
+        (call $$imported-throw)
+      )
+      (catch $$imported-e0 (i32.const 2))
+    )
+  )
+
+  (func (export "catchless-try") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do (local.get 0) (call $$throw-if))
+        )
+      )
+      (catch $$e0 (i32.const 1))
+    )
+  )
+)`);
+
+// ./test/core/try_catch.wast:152
+assert_return(() => invoke($1, `empty-catch`, []), []);
+
+// ./test/core/try_catch.wast:154
+assert_return(() => invoke($1, `simple-throw-catch`, [0]), [value("i32", 23)]);
+
+// ./test/core/try_catch.wast:155
+assert_return(() => invoke($1, `simple-throw-catch`, [1]), [value("i32", 42)]);
+
+// ./test/core/try_catch.wast:157
+assert_trap(() => invoke($1, `unreachable-not-caught`, []), `unreachable`);
+
+// ./test/core/try_catch.wast:159
+assert_return(() => invoke($1, `trap-in-callee`, [7, 2]), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:160
+assert_trap(() => invoke($1, `trap-in-callee`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/try_catch.wast:162
+assert_return(() => invoke($1, `catch-complex-1`, [0]), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:163
+assert_return(() => invoke($1, `catch-complex-1`, [1]), [value("i32", 4)]);
+
+// ./test/core/try_catch.wast:164
+assert_exception(() => invoke($1, `catch-complex-1`, [2]));
+
+// ./test/core/try_catch.wast:166
+assert_return(() => invoke($1, `catch-complex-2`, [0]), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:167
+assert_return(() => invoke($1, `catch-complex-2`, [1]), [value("i32", 4)]);
+
+// ./test/core/try_catch.wast:168
+assert_exception(() => invoke($1, `catch-complex-2`, [2]));
+
+// ./test/core/try_catch.wast:170
+assert_return(() => invoke($1, `throw-catch-param-i32`, [0]), [value("i32", 0)]);
+
+// ./test/core/try_catch.wast:171
+assert_return(() => invoke($1, `throw-catch-param-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/try_catch.wast:172
+assert_return(() => invoke($1, `throw-catch-param-i32`, [10]), [value("i32", 10)]);
+
+// ./test/core/try_catch.wast:174
+assert_return(() => invoke($1, `throw-catch-param-f32`, [value("f32", 5)]), [value("f32", 5)]);
+
+// ./test/core/try_catch.wast:175
+assert_return(() => invoke($1, `throw-catch-param-f32`, [value("f32", 10.5)]), [value("f32", 10.5)]);
+
+// ./test/core/try_catch.wast:177
+assert_return(() => invoke($1, `throw-catch-param-i64`, [5n]), [value("i64", 5n)]);
+
+// ./test/core/try_catch.wast:178
+assert_return(() => invoke($1, `throw-catch-param-i64`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/try_catch.wast:179
+assert_return(() => invoke($1, `throw-catch-param-i64`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/try_catch.wast:181
+assert_return(() => invoke($1, `throw-catch-param-f64`, [value("f64", 5)]), [value("f64", 5)]);
+
+// ./test/core/try_catch.wast:182
+assert_return(() => invoke($1, `throw-catch-param-f64`, [value("f64", 10.5)]), [value("f64", 10.5)]);
+
+// ./test/core/try_catch.wast:184
+assert_return(() => invoke($1, `catch-param-i32`, [5]), [value("i32", 5)]);
+
+// ./test/core/try_catch.wast:186
+assert_return(() => invoke($1, `catch-imported`, []), [value("i32", 2)]);
+
+// ./test/core/try_catch.wast:188
+assert_return(() => invoke($1, `catchless-try`, [0]), [value("i32", 0)]);
+
+// ./test/core/try_catch.wast:189
+assert_return(() => invoke($1, `catchless-try`, [1]), [value("i32", 1)]);
+
+// ./test/core/try_catch.wast:191
+let $2 = instantiate(`(module
+  (func $$imported-throw (import "test" "throw"))
+  (tag $$e0)
+
+  (func (export "imported-mismatch") (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do
+            (i32.const 1)
+            (call $$imported-throw)
+          )
+          (catch $$e0 (i32.const 2))
+        )
+      )
+      (catch_all (i32.const 3))
+    )
+  )
+)`);
+
+// ./test/core/try_catch.wast:211
+assert_return(() => invoke($2, `imported-mismatch`, []), [value("i32", 3)]);
+
+// ./test/core/try_catch.wast:213
+assert_malformed(() => instantiate(`(module (func (catch_all))) `), `unexpected token`);
+
+// ./test/core/try_catch.wast:218
+assert_malformed(
+  () => instantiate(`(module (tag $$e) (func (catch $$e))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_catch.wast:223
+assert_malformed(
+  () => instantiate(`(module (func (try (do) (catch_all) (catch_all)))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_catch.wast:230
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (try (result i32) (do))))`),
+  `type mismatch: instruction requires [i32] but stack has []`,
+);
+
+// ./test/core/try_catch.wast:232
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (try (result i32) (do (i64.const 42)))))`),
+  `type mismatch: instruction requires [i32] but stack has [i64]`,
+);
+
+// ./test/core/try_catch.wast:234
+assert_invalid(
+  () => instantiate(`(module (tag) (func (try (do) (catch 0 (i32.const 42)))))`),
+  `type mismatch: block requires [] but stack has [i32]`,
+);
+
+// ./test/core/try_catch.wast:236
+assert_invalid(
+  () => instantiate(`(module
+                  (tag (param i64))
+                  (func (result i32)
+                    (try (result i32) (do (i32.const 42)) (catch 0))))`),
+  `type mismatch: instruction requires [i32] but stack has [i64]`,
+);
+
+// ./test/core/try_catch.wast:241
+assert_invalid(
+  () => instantiate(`(module (func (try (do) (catch_all (i32.const 42)))))`),
+  `type mismatch: block requires [] but stack has [i32]`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js
new file mode 100644
index 0000000000..83400f02f5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/try_delegate.wast.js
@@ -0,0 +1,177 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/try_delegate.wast
+
+// ./test/core/try_delegate.wast:3
+let $0 = instantiate(`(module
+  (tag $$e0)
+  (tag $$e1)
+
+  (func (export "delegate-no-throw") (result i32)
+    (try $$t (result i32)
+      (do (try (result i32) (do (i32.const 1)) (delegate $$t)))
+      (catch $$e0 (i32.const 2))
+    )
+  )
+
+  (func $$throw-if (param i32)
+    (local.get 0)
+    (if (then (throw $$e0)) (else))
+  )
+
+  (func (export "delegate-throw") (param i32) (result i32)
+    (try $$t (result i32)
+      (do
+        (try (result i32)
+          (do (local.get 0) (call $$throw-if) (i32.const 1))
+          (delegate $$t)
+        )
+      )
+      (catch $$e0 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-skip") (result i32)
+    (try $$t (result i32)
+      (do
+        (try (result i32)
+          (do
+            (try (result i32)
+              (do (throw $$e0) (i32.const 1))
+              (delegate $$t)
+            )
+          )
+          (catch $$e0 (i32.const 2))
+        )
+      )
+      (catch $$e0 (i32.const 3))
+    )
+  )
+
+  (func (export "delegate-to-block") (result i32)
+    (try (result i32)
+      (do (block (try (do (throw $$e0)) (delegate 0)))
+          (i32.const 0))
+      (catch_all (i32.const 1)))
+  )
+
+  (func (export "delegate-to-catch") (result i32)
+    (try (result i32)
+      (do (try
+            (do (throw $$e0))
+            (catch $$e0
+              (try (do (rethrow 1)) (delegate 0))))
+          (i32.const 0))
+      (catch_all (i32.const 1)))
+  )
+
+  (func (export "delegate-to-caller")
+    (try (do (try (do (throw $$e0)) (delegate 1))) (catch_all))
+  )
+
+  (func $$select-tag (param i32)
+    (block (block (block (local.get 0) (br_table 0 1 2)) (return)) (throw $$e0))
+    (throw $$e1)
+  )
+
+  (func (export "delegate-merge") (param i32 i32) (result i32)
+    (try $$t (result i32)
+      (do
+        (local.get 0)
+        (call $$select-tag)
+        (try
+          (result i32)
+          (do (local.get 1) (call $$select-tag) (i32.const 1))
+          (delegate $$t)
+        )
+      )
+      (catch $$e0 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-throw-no-catch") (result i32)
+    (try (result i32)
+      (do (try (result i32) (do (throw $$e0) (i32.const 1)) (delegate 0)))
+      (catch $$e1 (i32.const 2))
+    )
+  )
+)`);
+
+// ./test/core/try_delegate.wast:97
+assert_return(() => invoke($0, `delegate-no-throw`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:99
+assert_return(() => invoke($0, `delegate-throw`, [0]), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:100
+assert_return(() => invoke($0, `delegate-throw`, [1]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:102
+assert_exception(() => invoke($0, `delegate-throw-no-catch`, []));
+
+// ./test/core/try_delegate.wast:104
+assert_return(() => invoke($0, `delegate-merge`, [1, 0]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:105
+assert_exception(() => invoke($0, `delegate-merge`, [2, 0]));
+
+// ./test/core/try_delegate.wast:106
+assert_return(() => invoke($0, `delegate-merge`, [0, 1]), [value("i32", 2)]);
+
+// ./test/core/try_delegate.wast:107
+assert_exception(() => invoke($0, `delegate-merge`, [0, 2]));
+
+// ./test/core/try_delegate.wast:108
+assert_return(() => invoke($0, `delegate-merge`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:110
+assert_return(() => invoke($0, `delegate-skip`, []), [value("i32", 3)]);
+
+// ./test/core/try_delegate.wast:112
+assert_return(() => invoke($0, `delegate-to-block`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:113
+assert_return(() => invoke($0, `delegate-to-catch`, []), [value("i32", 1)]);
+
+// ./test/core/try_delegate.wast:115
+assert_exception(() => invoke($0, `delegate-to-caller`, []));
+
+// ./test/core/try_delegate.wast:117
+assert_malformed(() => instantiate(`(module (func (delegate 0))) `), `unexpected token`);
+
+// ./test/core/try_delegate.wast:122
+assert_malformed(
+  () => instantiate(`(module (tag $$e) (func (try (do) (catch $$e) (delegate 0)))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:127
+assert_malformed(
+  () => instantiate(`(module (func (try (do) (catch_all) (delegate 0)))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:132
+assert_malformed(
+  () => instantiate(`(module (func (try (do) (delegate) (delegate 0)))) `),
+  `unexpected token`,
+);
+
+// ./test/core/try_delegate.wast:137
+assert_invalid(
+  () => instantiate(`(module (func (try (do) (delegate 1))))`),
+  `unknown label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js b/js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js
new file mode 100644
index 0000000000..20ee3b42c7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/exception-handling/unreached-valid.wast.js
@@ -0,0 +1,85 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/unreached-valid.wast
+
+// ./test/core/unreached-valid.wast:1
+let $0 = instantiate(`(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)
+  )
+)`);
+
+// ./test/core/unreached-valid.wast:42
+assert_trap(() => invoke($0, `select-trap-left`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:43
+assert_trap(() => invoke($0, `select-trap-left`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:44
+assert_trap(() => invoke($0, `select-trap-right`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:45
+assert_trap(() => invoke($0, `select-trap-right`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:49
+let $1 = instantiate(`(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)
+  )
+)`);
diff --git a/js/src/jit-test/tests/wasm/spec/extended-const/directives.txt b/js/src/jit-test/tests/wasm/spec/extended-const/directives.txt
new file mode 100644
index 0000000000..184e8d3e96
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/extended-const/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; --wasm-extended-const; skip-if: !wasmExtendedConstEnabled()
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/extended-const/global.wast.js b/js/src/jit-test/tests/wasm/spec/extended-const/global.wast.js
new file mode 100644
index 0000000000..c7dca890bd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/extended-const/global.wast.js
@@ -0,0 +1,828 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/global.wast
+
+// ./test/core/global.wast:3
+let $0 = instantiate(`(module
+  (global (import "spectest" "global_i32") i32)
+  (global (import "spectest" "global_i64") i64)
+
+  (global $$a i32 (i32.const -2))
+  (global (;3;) f32 (f32.const -3))
+  (global (;4;) f64 (f64.const -4))
+  (global $$b i64 (i64.const -5))
+
+  (global $$x (mut i32) (i32.const -12))
+  (global (;7;) (mut f32) (f32.const -13))
+  (global (;8;) (mut f64) (f64.const -14))
+  (global $$y (mut i64) (i64.const -15))
+
+  (global $$z1 i32 (global.get 0))
+  (global $$z2 i64 (global.get 1))
+  (global $$z3 i32 (i32.add (i32.sub (i32.mul (i32.const 20) (i32.const 2)) (i32.const 2)) (i32.const 4)))
+  (global $$z4 i64 (i64.add (i64.sub (i64.mul (i64.const 20) (i64.const 2)) (i64.const 2)) (i64.const 5)))
+  (global $$z5 i32 (i32.add (global.get 0) (i32.const 42)))
+  (global $$z6 i64 (i64.add (global.get 1) (i64.const 42)))
+
+  (global $$r externref (ref.null extern))
+  (global $$mr (mut externref) (ref.null extern))
+  (global funcref (ref.null func))
+
+  (func (export "get-a") (result i32) (global.get $$a))
+  (func (export "get-b") (result i64) (global.get $$b))
+  (func (export "get-r") (result externref) (global.get $$r))
+  (func (export "get-mr") (result externref) (global.get $$mr))
+  (func (export "get-x") (result i32) (global.get $$x))
+  (func (export "get-y") (result i64) (global.get $$y))
+  (func (export "get-z1") (result i32) (global.get $$z1))
+  (func (export "get-z2") (result i64) (global.get $$z2))
+  (func (export "get-z3") (result i32) (global.get $$z3))
+  (func (export "get-z4") (result i64) (global.get $$z4))
+  (func (export "get-z5") (result i32) (global.get $$z5))
+  (func (export "get-z6") (result i64) (global.get $$z6))
+  (func (export "set-x") (param i32) (global.set $$x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $$y (local.get 0)))
+  (func (export "set-mr") (param externref) (global.set $$mr (local.get 0)))
+
+  (func (export "get-3") (result f32) (global.get 3))
+  (func (export "get-4") (result f64) (global.get 4))
+  (func (export "get-7") (result f32) (global.get 7))
+  (func (export "get-8") (result f64) (global.get 8))
+  (func (export "set-7") (param f32) (global.set 7 (local.get 0)))
+  (func (export "set-8") (param f64) (global.set 8 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (global.get $$x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (global.get $$x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (global.get $$x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $$x) (call $$dummy) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $$dummy) (global.get $$x) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $$dummy) (call $$dummy) (global.get $$x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $$x)
+      (then (call $$dummy) (i32.const 2))
+      (else (call $$dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $$x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $$x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $$x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $$x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $$x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $$x) (br_table 0 0)
+    )
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (global.get $$x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (global.get $$x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (i32.const 0) (global.get $$x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $$x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $$x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $$x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (global.get $$x))
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $$f (global.get $$x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $$x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (global.get $$x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $$x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $$x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $$x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$x (global.get $$x))
+    (global.get $$x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $$x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $$x) (global.get $$x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+)`);
+
+// ./test/core/global.wast:204
+assert_return(() => invoke($0, `get-a`, []), [value("i32", -2)]);
+
+// ./test/core/global.wast:205
+assert_return(() => invoke($0, `get-b`, []), [value("i64", -5n)]);
+
+// ./test/core/global.wast:206
+assert_return(() => invoke($0, `get-r`, []), [value('externref', null)]);
+
+// ./test/core/global.wast:207
+assert_return(() => invoke($0, `get-mr`, []), [value('externref', null)]);
+
+// ./test/core/global.wast:208
+assert_return(() => invoke($0, `get-x`, []), [value("i32", -12)]);
+
+// ./test/core/global.wast:209
+assert_return(() => invoke($0, `get-y`, []), [value("i64", -15n)]);
+
+// ./test/core/global.wast:210
+assert_return(() => invoke($0, `get-z1`, []), [value("i32", 666)]);
+
+// ./test/core/global.wast:211
+assert_return(() => invoke($0, `get-z2`, []), [value("i64", 666n)]);
+
+// ./test/core/global.wast:212
+assert_return(() => invoke($0, `get-z3`, []), [value("i32", 42)]);
+
+// ./test/core/global.wast:213
+assert_return(() => invoke($0, `get-z4`, []), [value("i64", 43n)]);
+
+// ./test/core/global.wast:214
+assert_return(() => invoke($0, `get-z5`, []), [value("i32", 708)]);
+
+// ./test/core/global.wast:215
+assert_return(() => invoke($0, `get-z6`, []), [value("i64", 708n)]);
+
+// ./test/core/global.wast:217
+assert_return(() => invoke($0, `get-3`, []), [value("f32", -3)]);
+
+// ./test/core/global.wast:218
+assert_return(() => invoke($0, `get-4`, []), [value("f64", -4)]);
+
+// ./test/core/global.wast:219
+assert_return(() => invoke($0, `get-7`, []), [value("f32", -13)]);
+
+// ./test/core/global.wast:220
+assert_return(() => invoke($0, `get-8`, []), [value("f64", -14)]);
+
+// ./test/core/global.wast:222
+assert_return(() => invoke($0, `set-x`, [6]), []);
+
+// ./test/core/global.wast:223
+assert_return(() => invoke($0, `set-y`, [7n]), []);
+
+// ./test/core/global.wast:225
+assert_return(() => invoke($0, `set-7`, [value("f32", 8)]), []);
+
+// ./test/core/global.wast:226
+assert_return(() => invoke($0, `set-8`, [value("f64", 9)]), []);
+
+// ./test/core/global.wast:228
+assert_return(() => invoke($0, `get-x`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:229
+assert_return(() => invoke($0, `get-y`, []), [value("i64", 7n)]);
+
+// ./test/core/global.wast:230
+assert_return(() => invoke($0, `get-7`, []), [value("f32", 8)]);
+
+// ./test/core/global.wast:231
+assert_return(() => invoke($0, `get-8`, []), [value("f64", 9)]);
+
+// ./test/core/global.wast:233
+assert_return(() => invoke($0, `set-7`, [value("f32", 8)]), []);
+
+// ./test/core/global.wast:234
+assert_return(() => invoke($0, `set-8`, [value("f64", 9)]), []);
+
+// ./test/core/global.wast:235
+assert_return(() => invoke($0, `set-mr`, [externref(10)]), []);
+
+// ./test/core/global.wast:237
+assert_return(() => invoke($0, `get-x`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:238
+assert_return(() => invoke($0, `get-y`, []), [value("i64", 7n)]);
+
+// ./test/core/global.wast:239
+assert_return(() => invoke($0, `get-7`, []), [value("f32", 8)]);
+
+// ./test/core/global.wast:240
+assert_return(() => invoke($0, `get-8`, []), [value("f64", 9)]);
+
+// ./test/core/global.wast:241
+assert_return(() => invoke($0, `get-mr`, []), [value('externref', externref(10))]);
+
+// ./test/core/global.wast:243
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:244
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:245
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:247
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:248
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:249
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:251
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:252
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:253
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:255
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:256
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:258
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:259
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:261
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:262
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:263
+assert_trap(() => invoke($0, `as-call_indirect-last`, []), `undefined element`);
+
+// ./test/core/global.wast:265
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/global.wast:266
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/global.wast:267
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:268
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:270
+assert_return(() => invoke($0, `as-call-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:272
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:273
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/global.wast:274
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:276
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 6)]);
+
+// ./test/core/global.wast:277
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 6)]);
+
+// ./test/core/global.wast:278
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:280
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 0)]);
+
+// ./test/core/global.wast:281
+assert_return(() => invoke($0, `as-binary-operand`, []), [value("i32", 36)]);
+
+// ./test/core/global.wast:282
+assert_return(() => invoke($0, `as-compare-operand`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:284
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))`),
+  `global is immutable`,
+);
+
+// ./test/core/global.wast:289
+assert_invalid(
+  () => instantiate(`(module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1))))`),
+  `global is immutable`,
+);
+
+// ./test/core/global.wast:295
+let $1 = instantiate(`(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))`);
+
+// ./test/core/global.wast:296
+let $2 = instantiate(`(module (global (export "a") (mut f32) (f32.const 0)))`);
+
+// ./test/core/global.wast:298
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.neg (f32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:303
+assert_invalid(
+  () => instantiate(`(module (global f32 (local.get 0)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:308
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.neg (f32.const 1))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:313
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0) (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:318
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.ctz (i32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:323
+assert_invalid(
+  () => instantiate(`(module (global i32 (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:328
+assert_invalid(() => instantiate(`(module (global i32 (f32.const 0)))`), `type mismatch`);
+
+// ./test/core/global.wast:333
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0) (i32.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:338
+assert_invalid(
+  () => instantiate(`(module (global i32 (;empty instruction sequence;)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:343
+assert_invalid(
+  () => instantiate(`(module (global (import "" "") externref) (global funcref (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:348
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (global.get 0) (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:353
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (i32.const 0) (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:358
+assert_invalid(
+  () => instantiate(`(module (global i32 (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:363
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0)) (global i32 (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:367
+assert_invalid(
+  () => instantiate(`(module (global $$g i32 (i32.const 0)) (global i32 (global.get $$g)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:372
+assert_invalid(
+  () => instantiate(`(module (global i32 (global.get 1)) (global i32 (i32.const 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:377
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (global.get 2)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:382
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-mut-i32") (mut i32)) (global i32 (global.get 0)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:387
+let $3 = instantiate(`(module
+  (import "spectest" "global_i32" (global i32))
+)`);
+
+// ./test/core/global.wast:390
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\98\\80\\80\\80\\00"             ;; import section
+      "\\01"                          ;; length 1
+      "\\08\\73\\70\\65\\63\\74\\65\\73\\74"  ;; "spectest"
+      "\\0a\\67\\6c\\6f\\62\\61\\6c\\5f\\69\\33\\32" ;; "global_i32"
+      "\\03"                          ;; GlobalImport
+      "\\7f"                          ;; i32
+      "\\02"                          ;; malformed mutability
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:403
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\98\\80\\80\\80\\00"             ;; import section
+      "\\01"                          ;; length 1
+      "\\08\\73\\70\\65\\63\\74\\65\\73\\74"  ;; "spectest"
+      "\\0a\\67\\6c\\6f\\62\\61\\6c\\5f\\69\\33\\32" ;; "global_i32"
+      "\\03"                          ;; GlobalImport
+      "\\7f"                          ;; i32
+      "\\ff"                          ;; malformed mutability
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:417
+let $4 = instantiate(`(module
+  (global i32 (i32.const 0))
+)`);
+
+// ./test/core/global.wast:420
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\06\\86\\80\\80\\80\\00"  ;; global section
+      "\\01"               ;; length 1
+      "\\7f"               ;; i32
+      "\\02"               ;; malformed mutability
+      "\\41\\00"            ;; i32.const 0
+      "\\0b"               ;; end
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:432
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\06\\86\\80\\80\\80\\00"  ;; global section
+      "\\01"               ;; length 1
+      "\\7f"               ;; i32
+      "\\ff"               ;; malformed mutability
+      "\\41\\00"            ;; i32.const 0
+      "\\0b"               ;; end
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:446
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:451
+assert_invalid(
+  () => instantiate(`(module
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:459
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (func (result i32) (global.get 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:467
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 2))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:477
+assert_invalid(
+  () => instantiate(`(module (func (i32.const 0) (global.set 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:482
+assert_invalid(
+  () => instantiate(`(module
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:490
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (func (i32.const 0) (global.set 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:498
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 2))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:508
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty
+      (global.set $$x)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:517
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-block
+      (i32.const 0)
+      (block (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:527
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-loop
+      (i32.const 0)
+      (loop (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:537
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:547
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:557
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:567
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:577
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:587
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-return
+      (return (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:596
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-select
+      (select (global.set $$x) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:605
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-call
+      (call 1 (global.set $$x))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:615
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-global.set-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (global.set $$x) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:634
+assert_malformed(
+  () => instantiate(`(global $$foo i32 (i32.const 0)) (global $$foo i32 (i32.const 0)) `),
+  `duplicate global`,
+);
+
+// ./test/core/global.wast:638
+assert_malformed(
+  () => instantiate(`(import "" "" (global $$foo i32)) (global $$foo i32 (i32.const 0)) `),
+  `duplicate global`,
+);
+
+// ./test/core/global.wast:642
+assert_malformed(
+  () => instantiate(`(import "" "" (global $$foo i32)) (import "" "" (global $$foo i32)) `),
+  `duplicate global`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/extended-const/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/extended-const/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/extended-const/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/extended-const/harness/harness.js b/js/src/jit-test/tests/wasm/spec/extended-const/harness/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/extended-const/harness/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: 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",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/br_if.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/br_if.wast.js
new file mode 100644
index 0000000000..511ee003fb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/br_if.wast.js
@@ -0,0 +1,886 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/br_if.wast
+
+// ./test/core/br_if.wast:3
+let $0 = instantiate(`(module
+  (func $$dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_if 0 (i32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_if 0 (i64.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_if 0 (f32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_if 0 (f64.const 0) (i32.const 1)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_if 0 (f32.const 3) (i32.const 1))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 4) (i32.const 1))))
+  )
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (call $$dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
+    (i32.const 3)
+  )
+  (func (export "as-block-last") (param i32)
+    (block (call $$dummy) (call $$dummy) (br_if 0 (local.get 0)))
+  )
+  (func (export "as-block-first-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11))
+    )
+  )
+  (func (export "as-block-mid-value") (param i32) (result i32)
+    (block (result i32)
+      (call $$dummy)
+      (drop (br_if 0 (i32.const 20) (local.get 0)))
+      (return (i32.const 21))
+    )
+  )
+  (func (export "as-block-last-value") (param i32) (result i32)
+    (block (result i32)
+      (call $$dummy) (call $$dummy) (br_if 0 (i32.const 11) (local.get 0))
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (block (loop (call $$dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
+    (i32.const 4)
+  )
+  (func (export "as-loop-last") (param i32)
+    (loop (call $$dummy) (br_if 1 (local.get 0)))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)))
+      (i32.const 4)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0))))
+      (i32.const 4)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4)
+    )
+  )
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (local.get 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32)
+    (block
+      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $$dummy)))
+    )
+  )
+  (func (export "as-if-else") (param i32 i32)
+    (block
+      (if (local.get 0) (then (call $$dummy)) (else (br_if 1 (local.get 1))))
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (block (result i32)
+      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-select-second") (param i32) (result i32)
+    (block (result i32)
+      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (local.get 0))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 1) (i32.const 2) (br_if 0 (i32.const 3) (i32.const 10)))
+    )
+  )
+
+ (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $$f
+        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $$f
+        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $$f
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (func $$func (param i32 i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (br_if 0 (i32.const 4) (i32.const 10))
+        (i32.const 1) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (i32.const 3) (br_if 0 (i32.const 4) (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (block (result i32)
+      (local.tee 0 (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (block (result i32)
+      (global.set $$a (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result i32)
+    (block (result i32) (i32.load (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (block (result i32) (i32.load8_s (br_if 0 (i32.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (i32.store (br_if 0 (i32.const 30) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i32.store (i32.const 2) (br_if 0 (i32.const 31) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_if 0 (i32.const 32) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i32.store16 (i32.const 2) (br_if 0 (i32.const 33) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
+  )
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (i32.add
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0)))
+            (i32.const 16)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+)`);
+
+// ./test/core/br_if.wast:372
+assert_return(() => invoke($0, `type-i32`, []), []);
+
+// ./test/core/br_if.wast:373
+assert_return(() => invoke($0, `type-i64`, []), []);
+
+// ./test/core/br_if.wast:374
+assert_return(() => invoke($0, `type-f32`, []), []);
+
+// ./test/core/br_if.wast:375
+assert_return(() => invoke($0, `type-f64`, []), []);
+
+// ./test/core/br_if.wast:377
+assert_return(() => invoke($0, `type-i32-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:378
+assert_return(() => invoke($0, `type-i64-value`, []), [value("i64", 2n)]);
+
+// ./test/core/br_if.wast:379
+assert_return(() => invoke($0, `type-f32-value`, []), [value("f32", 3)]);
+
+// ./test/core/br_if.wast:380
+assert_return(() => invoke($0, `type-f64-value`, []), [value("f64", 4)]);
+
+// ./test/core/br_if.wast:382
+assert_return(() => invoke($0, `as-block-first`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:383
+assert_return(() => invoke($0, `as-block-first`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:384
+assert_return(() => invoke($0, `as-block-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:385
+assert_return(() => invoke($0, `as-block-mid`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:386
+assert_return(() => invoke($0, `as-block-last`, [0]), []);
+
+// ./test/core/br_if.wast:387
+assert_return(() => invoke($0, `as-block-last`, [1]), []);
+
+// ./test/core/br_if.wast:389
+assert_return(() => invoke($0, `as-block-first-value`, [0]), [value("i32", 11)]);
+
+// ./test/core/br_if.wast:390
+assert_return(() => invoke($0, `as-block-first-value`, [1]), [value("i32", 10)]);
+
+// ./test/core/br_if.wast:391
+assert_return(() => invoke($0, `as-block-mid-value`, [0]), [value("i32", 21)]);
+
+// ./test/core/br_if.wast:392
+assert_return(() => invoke($0, `as-block-mid-value`, [1]), [value("i32", 20)]);
+
+// ./test/core/br_if.wast:393
+assert_return(() => invoke($0, `as-block-last-value`, [0]), [value("i32", 11)]);
+
+// ./test/core/br_if.wast:394
+assert_return(() => invoke($0, `as-block-last-value`, [1]), [value("i32", 11)]);
+
+// ./test/core/br_if.wast:396
+assert_return(() => invoke($0, `as-loop-first`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:397
+assert_return(() => invoke($0, `as-loop-first`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:398
+assert_return(() => invoke($0, `as-loop-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:399
+assert_return(() => invoke($0, `as-loop-mid`, [1]), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:400
+assert_return(() => invoke($0, `as-loop-last`, [0]), []);
+
+// ./test/core/br_if.wast:401
+assert_return(() => invoke($0, `as-loop-last`, [1]), []);
+
+// ./test/core/br_if.wast:403
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:405
+assert_return(() => invoke($0, `as-br_if-cond`, []), []);
+
+// ./test/core/br_if.wast:406
+assert_return(() => invoke($0, `as-br_if-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:407
+assert_return(() => invoke($0, `as-br_if-value-cond`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:408
+assert_return(() => invoke($0, `as-br_if-value-cond`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:410
+assert_return(() => invoke($0, `as-br_table-index`, []), []);
+
+// ./test/core/br_if.wast:411
+assert_return(() => invoke($0, `as-br_table-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:412
+assert_return(() => invoke($0, `as-br_table-value-index`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:414
+assert_return(() => invoke($0, `as-return-value`, []), [value("i64", 1n)]);
+
+// ./test/core/br_if.wast:416
+assert_return(() => invoke($0, `as-if-cond`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:417
+assert_return(() => invoke($0, `as-if-cond`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:418
+assert_return(() => invoke($0, `as-if-then`, [0, 0]), []);
+
+// ./test/core/br_if.wast:419
+assert_return(() => invoke($0, `as-if-then`, [4, 0]), []);
+
+// ./test/core/br_if.wast:420
+assert_return(() => invoke($0, `as-if-then`, [0, 1]), []);
+
+// ./test/core/br_if.wast:421
+assert_return(() => invoke($0, `as-if-then`, [4, 1]), []);
+
+// ./test/core/br_if.wast:422
+assert_return(() => invoke($0, `as-if-else`, [0, 0]), []);
+
+// ./test/core/br_if.wast:423
+assert_return(() => invoke($0, `as-if-else`, [3, 0]), []);
+
+// ./test/core/br_if.wast:424
+assert_return(() => invoke($0, `as-if-else`, [0, 1]), []);
+
+// ./test/core/br_if.wast:425
+assert_return(() => invoke($0, `as-if-else`, [3, 1]), []);
+
+// ./test/core/br_if.wast:427
+assert_return(() => invoke($0, `as-select-first`, [0]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:428
+assert_return(() => invoke($0, `as-select-first`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:429
+assert_return(() => invoke($0, `as-select-second`, [0]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:430
+assert_return(() => invoke($0, `as-select-second`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:431
+assert_return(() => invoke($0, `as-select-cond`, []), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:433
+assert_return(() => invoke($0, `as-call-first`, []), [value("i32", 12)]);
+
+// ./test/core/br_if.wast:434
+assert_return(() => invoke($0, `as-call-mid`, []), [value("i32", 13)]);
+
+// ./test/core/br_if.wast:435
+assert_return(() => invoke($0, `as-call-last`, []), [value("i32", 14)]);
+
+// ./test/core/br_if.wast:437
+assert_return(() => invoke($0, `as-call_indirect-func`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:438
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:439
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:440
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:442
+assert_return(() => invoke($0, `as-local.set-value`, [0]), [value("i32", -1)]);
+
+// ./test/core/br_if.wast:443
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 17)]);
+
+// ./test/core/br_if.wast:445
+assert_return(() => invoke($0, `as-local.tee-value`, [0]), [value("i32", -1)]);
+
+// ./test/core/br_if.wast:446
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:448
+assert_return(() => invoke($0, `as-global.set-value`, [0]), [value("i32", -1)]);
+
+// ./test/core/br_if.wast:449
+assert_return(() => invoke($0, `as-global.set-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:451
+assert_return(() => invoke($0, `as-load-address`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:452
+assert_return(() => invoke($0, `as-loadN-address`, []), [value("i32", 30)]);
+
+// ./test/core/br_if.wast:454
+assert_return(() => invoke($0, `as-store-address`, []), [value("i32", 30)]);
+
+// ./test/core/br_if.wast:455
+assert_return(() => invoke($0, `as-store-value`, []), [value("i32", 31)]);
+
+// ./test/core/br_if.wast:456
+assert_return(() => invoke($0, `as-storeN-address`, []), [value("i32", 32)]);
+
+// ./test/core/br_if.wast:457
+assert_return(() => invoke($0, `as-storeN-value`, []), [value("i32", 33)]);
+
+// ./test/core/br_if.wast:459
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f64", 1)]);
+
+// ./test/core/br_if.wast:460
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:461
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:462
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/br_if.wast:463
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:464
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:465
+assert_return(() => invoke($0, `as-memory.grow-size`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:467
+assert_return(() => invoke($0, `nested-block-value`, [0]), [value("i32", 21)]);
+
+// ./test/core/br_if.wast:468
+assert_return(() => invoke($0, `nested-block-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:469
+assert_return(() => invoke($0, `nested-br-value`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:470
+assert_return(() => invoke($0, `nested-br-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:471
+assert_return(() => invoke($0, `nested-br_if-value`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:472
+assert_return(() => invoke($0, `nested-br_if-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:473
+assert_return(() => invoke($0, `nested-br_if-value-cond`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:474
+assert_return(() => invoke($0, `nested-br_if-value-cond`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:475
+assert_return(() => invoke($0, `nested-br_table-value`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:476
+assert_return(() => invoke($0, `nested-br_table-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:477
+assert_return(() => invoke($0, `nested-br_table-value-index`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:478
+assert_return(() => invoke($0, `nested-br_table-value-index`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:480
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-i32 (block (i32.ctz (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:484
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-i64 (block (i64.ctz (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:488
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-f32 (block (f32.neg (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:492
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-f64 (block (f64.neg (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:497
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-i32 (block (i32.ctz (br_if 0 (i32.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:501
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-i64 (block (i64.ctz (br_if 0 (i64.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:505
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-f32 (block (f32.neg (br_if 0 (f32.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:509
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-f64 (block (f64.neg (br_if 0 (i64.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:514
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:520
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:526
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:532
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:539
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:545
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:551
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:559
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:568
+assert_invalid(
+  () => instantiate(`(module (func $$type-cond-empty-vs-i32
+    (block (br_if 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:574
+assert_invalid(
+  () => instantiate(`(module (func $$type-cond-void-vs-i32
+    (block (br_if 0 (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:580
+assert_invalid(
+  () => instantiate(`(module (func $$type-cond-num-vs-i32
+    (block (br_if 0 (i64.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:586
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-cond-void-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:592
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:598
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-cond-num-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:605
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-1st-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:617
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-2nd-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:629
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-1st-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:640
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-2nd-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:653
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-label (br_if 1 (i32.const 1))))`),
+  `unknown label`,
+);
+
+// ./test/core/br_if.wast:657
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-nested-label (block (block (br_if 5 (i32.const 1))))))`),
+  `unknown label`,
+);
+
+// ./test/core/br_if.wast:661
+assert_invalid(
+  () => instantiate(`(module (func $$large-label (br_if 0x10000001 (i32.const 1))))`),
+  `unknown label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/br_on_non_null.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/br_on_non_null.wast.js
new file mode 100644
index 0000000000..16a778a8e4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/br_on_non_null.wast.js
@@ -0,0 +1,101 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/br_on_non_null.wast
+
+// ./test/core/br_on_non_null.wast:1
+let $0 = instantiate(`(module
+  (type $$t (func (result i32)))
+
+  (func $$nn (param $$r (ref $$t)) (result i32)
+    (call_ref $$t
+      (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 $$t
+      (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 (result (ref $$t))
+      (br_on_non_null $$l (unreachable))
+      (return (i32.const -1))
+    )
+    (call_ref $$t)
+  )
+)`);
+
+// ./test/core/br_on_non_null.wast:37
+assert_trap(() => invoke($0, `unreachable`, []), `unreachable`);
+
+// ./test/core/br_on_non_null.wast:39
+assert_return(() => invoke($0, `nullable-null`, []), [value("i32", -1)]);
+
+// ./test/core/br_on_non_null.wast:40
+assert_return(() => invoke($0, `nonnullable-f`, []), [value("i32", 7)]);
+
+// ./test/core/br_on_non_null.wast:41
+assert_return(() => invoke($0, `nullable-f`, []), [value("i32", 7)]);
+
+// ./test/core/br_on_non_null.wast:43
+let $1 = instantiate(`(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))))
+)`);
+
+// ./test/core/br_on_non_null.wast:51
+let $2 = instantiate(`(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 $$t
+      (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))
+  )
+)`);
+
+// ./test/core/br_on_non_null.wast:72
+assert_return(() => invoke($2, `args-null`, [3]), [value("i32", 3)]);
+
+// ./test/core/br_on_non_null.wast:73
+assert_return(() => invoke($2, `args-f`, [3]), [value("i32", 9)]);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/br_on_null.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/br_on_null.wast.js
new file mode 100644
index 0000000000..3335e22930
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/br_on_null.wast.js
@@ -0,0 +1,94 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/br_on_null.wast
+
+// ./test/core/br_on_null.wast:1
+let $0 = instantiate(`(module
+  (type $$t (func (result i32)))
+
+  (func $$nn (param $$r (ref $$t)) (result i32)
+    (block $$l
+      (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 $$t (br_on_null $$l (local.get $$r))))
+    )
+    (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 $$t (br_on_null $$l (unreachable))))
+    )
+    (i32.const -1)
+  )
+)`);
+
+// ./test/core/br_on_null.wast:32
+assert_trap(() => invoke($0, `unreachable`, []), `unreachable`);
+
+// ./test/core/br_on_null.wast:34
+assert_return(() => invoke($0, `nullable-null`, []), [value("i32", -1)]);
+
+// ./test/core/br_on_null.wast:35
+assert_return(() => invoke($0, `nonnullable-f`, []), [value("i32", 7)]);
+
+// ./test/core/br_on_null.wast:36
+assert_return(() => invoke($0, `nullable-f`, []), [value("i32", 7)]);
+
+// ./test/core/br_on_null.wast:38
+let $1 = instantiate(`(module
+  (type $$t (func))
+  (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))))
+)`);
+
+// ./test/core/br_on_null.wast:46
+let $2 = instantiate(`(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)
+    (block $$l (result i32)
+      (return (call_ref $$t (br_on_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))
+  )
+)`);
+
+// ./test/core/br_on_null.wast:65
+assert_return(() => invoke($2, `args-null`, [3]), [value("i32", 3)]);
+
+// ./test/core/br_on_null.wast:66
+assert_return(() => invoke($2, `args-f`, [3]), [value("i32", 9)]);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/call_indirect.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/call_indirect.wast.js
new file mode 100644
index 0000000000..cde2d92cef
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/call_indirect.wast.js
@@ -0,0 +1,1240 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/call_indirect.wast
+
+// ./test/core/call_indirect.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definitions
+  (type $$proc (func))
+  (type $$out-i32 (func (result i32)))
+  (type $$out-i64 (func (result i64)))
+  (type $$out-f32 (func (result f32)))
+  (type $$out-f64 (func (result f64)))
+  (type $$out-f64-i32 (func (result f64 i32)))
+  (type $$over-i32 (func (param i32) (result i32)))
+  (type $$over-i64 (func (param i64) (result i64)))
+  (type $$over-f32 (func (param f32) (result f32)))
+  (type $$over-f64 (func (param f64) (result f64)))
+  (type $$over-i32-f64 (func (param i32 f64) (result i32 f64)))
+  (type $$swap-i32-i64 (func (param i32 i64) (result i64 i32)))
+  (type $$f32-i32 (func (param f32 i32) (result i32)))
+  (type $$i32-i64 (func (param i32 i64) (result i64)))
+  (type $$f64-f32 (func (param f64 f32) (result f32)))
+  (type $$i64-f64 (func (param i64 f64) (result f64)))
+  (type $$over-i32-duplicate (func (param i32) (result i32)))
+  (type $$over-i64-duplicate (func (param i64) (result i64)))
+  (type $$over-f32-duplicate (func (param f32) (result f32)))
+  (type $$over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $$const-i32 (type $$out-i32) (i32.const 0x132))
+  (func $$const-i64 (type $$out-i64) (i64.const 0x164))
+  (func $$const-f32 (type $$out-f32) (f32.const 0xf32))
+  (func $$const-f64 (type $$out-f64) (f64.const 0xf64))
+  (func $$const-f64-i32 (type $$out-f64-i32) (f64.const 0xf64) (i32.const 32))
+
+  (func $$id-i32 (type $$over-i32) (local.get 0))
+  (func $$id-i64 (type $$over-i64) (local.get 0))
+  (func $$id-f32 (type $$over-f32) (local.get 0))
+  (func $$id-f64 (type $$over-f64) (local.get 0))
+  (func $$id-i32-f64 (type $$over-i32-f64) (local.get 0) (local.get 1))
+  (func $$swap-i32-i64 (type $$swap-i32-i64) (local.get 1) (local.get 0))
+
+  (func $$i32-i64 (type $$i32-i64) (local.get 1))
+  (func $$i64-f64 (type $$i64-f64) (local.get 1))
+  (func $$f32-i32 (type $$f32-i32) (local.get 1))
+  (func $$f64-f32 (type $$f64-f32) (local.get 1))
+
+  (func $$over-i32-duplicate (type $$over-i32-duplicate) (local.get 0))
+  (func $$over-i64-duplicate (type $$over-i64-duplicate) (local.get 0))
+  (func $$over-f32-duplicate (type $$over-f32-duplicate) (local.get 0))
+  (func $$over-f64-duplicate (type $$over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $$const-i32 $$const-i64 $$const-f32 $$const-f64  ;; 0..3
+      $$id-i32 $$id-i64 $$id-f32 $$id-f64              ;; 4..7
+      $$f32-i32 $$i32-i64 $$f64-f32 $$i64-f64          ;; 9..11
+      $$fac-i64 $$fib-i64 $$even $$odd                 ;; 12..15
+      $$runaway $$mutual-runaway1 $$mutual-runaway2   ;; 16..18
+      $$over-i32-duplicate $$over-i64-duplicate      ;; 19..20
+      $$over-f32-duplicate $$over-f64-duplicate      ;; 21..22
+      $$fac-i32 $$fac-f32 $$fac-f64                   ;; 23..25
+      $$fib-i32 $$fib-f32 $$fib-f64                   ;; 26..28
+      $$const-f64-i32 $$id-i32-f64 $$swap-i32-i64     ;; 29..31
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (call_indirect (i32.const 0))
+    (call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (call_indirect (result) (i32.const 0))
+    (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+    (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+    (drop (i32.eqz
+      (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    ))
+    (drop (i32.eqz
+      (call_indirect
+        (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+        (result) (result i32) (result) (result)
+        (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+      )
+    ))
+    (drop (i64.eqz
+      (call_indirect (type $$over-i64) (param i64) (result i64)
+        (i64.const 0) (i32.const 0)
+      )
+    ))
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (call_indirect (type $$out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (call_indirect (type $$out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (call_indirect (type $$out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (call_indirect (type $$out-f64) (i32.const 3))
+  )
+  (func (export "type-f64-i32") (result f64 i32)
+    (call_indirect (type $$out-f64-i32) (i32.const 29))
+  )
+
+  (func (export "type-index") (result i64)
+    (call_indirect (type $$over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (call_indirect (type $$over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (call_indirect (type $$over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (call_indirect (type $$over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (call_indirect (type $$over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (call_indirect (type $$f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call_indirect (type $$i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call_indirect (type $$f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call_indirect (type $$i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
+  )
+
+  (func (export "type-all-f64-i32") (result f64 i32)
+    (call_indirect (type $$out-f64-i32) (i32.const 29))
+  )
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call_indirect (type $$over-i32-f64)
+      (i32.const 1) (f64.const 2) (i32.const 30)
+    )
+  )
+  (func (export "type-all-i32-i64") (result i64 i32)
+    (call_indirect (type $$swap-i32-i64)
+      (i32.const 1) (i64.const 2) (i32.const 31)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (call_indirect (type $$over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural-i64") (param i32) (result i64)
+    (call_indirect (type $$over-i64-duplicate) (i64.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-i32") (param i32) (result i32)
+    (call_indirect (type $$over-i32-duplicate) (i32.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-f32") (param i32) (result f32)
+    (call_indirect (type $$over-f32-duplicate) (f32.const 9.0) (local.get 0))
+  )
+  (func (export "dispatch-structural-f64") (param i32) (result f64)
+    (call_indirect (type $$over-f64-duplicate) (f64.const 9.0) (local.get 0))
+  )
+
+  ;; Recursion
+
+  (func $$fac-i64 (export "fac-i64") (type $$over-i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 12)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-i64 (export "fib-i64") (type $$over-i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 2))
+            (i32.const 13)
+          )
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 13)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-i32 (export "fac-i32") (type $$over-i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 1))
+      (else
+        (i32.mul
+          (local.get 0)
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-f32 (export "fac-f32") (type $$over-f32)
+    (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.mul
+          (local.get 0)
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 24)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-f64 (export "fac-f64") (type $$over-f64)
+    (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.mul
+          (local.get 0)
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 25)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-i32 (export "fib-i32") (type $$over-i32)
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 2))
+            (i32.const 26)
+          )
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 26)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-f32 (export "fib-f32") (type $$over-f32)
+    (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.add
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 2.0))
+            (i32.const 27)
+          )
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 27)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-f64 (export "fib-f64") (type $$over-f64)
+    (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.add
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 2.0))
+            (i32.const 28)
+          )
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 28)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (call_indirect (type $$over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $$odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (call_indirect (type $$over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $$runaway (export "runaway") (call_indirect (type $$proc) (i32.const 16)))
+
+  (func $$mutual-runaway1 (export "mutual-runaway") (call_indirect (type $$proc) (i32.const 18)))
+  (func $$mutual-runaway2 (call_indirect (type $$proc) (i32.const 17)))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call_indirect (type $$out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i64)
+    (block (result i64) (br_if 0 (call_indirect (type $$out-i64) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0))))
+  )
+
+  (func (export "as-br_table-first") (result f32)
+    (block (result f32) (call_indirect (type $$out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (br_table 0 0))
+  )
+
+  (func (export "as-store-first")
+    (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call_indirect (type $$out-f64) (i32.const 3)) (f64.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+  (func (export "as-return-value") (result i32)
+    (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4)) (return)
+  )
+  (func (export "as-drop-operand")
+    (call_indirect (type $$over-i64) (i64.const 1) (i32.const 5)) (drop)
+  )
+  (func (export "as-br-value") (result f32)
+    (block (result f32) (br 0 (call_indirect (type $$over-f32) (f32.const 1) (i32.const 6))))
+  )
+  (func (export "as-local.set-value") (result f64)
+    (local f64) (local.set 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result f64)
+    (local f64) (local.tee 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7)))
+  )
+  (global $$a (mut f64) (f64.const 10.0))
+  (func (export "as-global.set-value") (result f64)
+    (global.set $$a (call_indirect (type $$over-f64) (f64.const 1.0) (i32.const 7)))
+    (global.get $$a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32)
+      (f32.sqrt
+        (call_indirect (type $$over-f32) (f32.const 0x0p+0) (i32.const 6))
+      )
+    )
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32)
+      (i32.sub
+        (i32.const 10)
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32)
+      (i32.eqz
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (i32.le_u
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (i32.ne
+        (i32.const 10)
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64)
+      (i64.extend_i32_s
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+)`);
+
+// ./test/core/call_indirect.wast:471
+assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:472
+assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:473
+assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:474
+assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]);
+
+// ./test/core/call_indirect.wast:475
+assert_return(() => invoke($0, `type-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:477
+assert_return(() => invoke($0, `type-index`, []), [value("i64", 100n)]);
+
+// ./test/core/call_indirect.wast:479
+assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:480
+assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:481
+assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]);
+
+// ./test/core/call_indirect.wast:482
+assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]);
+
+// ./test/core/call_indirect.wast:484
+assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:485
+assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:486
+assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]);
+
+// ./test/core/call_indirect.wast:487
+assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]);
+
+// ./test/core/call_indirect.wast:489
+assert_return(() => invoke($0, `type-all-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:490
+assert_return(() => invoke($0, `type-all-i32-f64`, []), [value("i32", 1), value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:491
+assert_return(() => invoke($0, `type-all-i32-i64`, []), [value("i64", 2n), value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:493
+assert_return(() => invoke($0, `dispatch`, [5, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:494
+assert_return(() => invoke($0, `dispatch`, [5, 5n]), [value("i64", 5n)]);
+
+// ./test/core/call_indirect.wast:495
+assert_return(() => invoke($0, `dispatch`, [12, 5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:496
+assert_return(() => invoke($0, `dispatch`, [13, 5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:497
+assert_return(() => invoke($0, `dispatch`, [20, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:498
+assert_trap(() => invoke($0, `dispatch`, [0, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:499
+assert_trap(() => invoke($0, `dispatch`, [15, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:500
+assert_trap(() => invoke($0, `dispatch`, [32, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:501
+assert_trap(() => invoke($0, `dispatch`, [-1, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:502
+assert_trap(() => invoke($0, `dispatch`, [1213432423, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:504
+assert_return(() => invoke($0, `dispatch-structural-i64`, [5]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:505
+assert_return(() => invoke($0, `dispatch-structural-i64`, [12]), [value("i64", 362880n)]);
+
+// ./test/core/call_indirect.wast:506
+assert_return(() => invoke($0, `dispatch-structural-i64`, [13]), [value("i64", 55n)]);
+
+// ./test/core/call_indirect.wast:507
+assert_return(() => invoke($0, `dispatch-structural-i64`, [20]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:508
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [11]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:509
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [22]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:511
+assert_return(() => invoke($0, `dispatch-structural-i32`, [4]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:512
+assert_return(() => invoke($0, `dispatch-structural-i32`, [23]), [value("i32", 362880)]);
+
+// ./test/core/call_indirect.wast:513
+assert_return(() => invoke($0, `dispatch-structural-i32`, [26]), [value("i32", 55)]);
+
+// ./test/core/call_indirect.wast:514
+assert_return(() => invoke($0, `dispatch-structural-i32`, [19]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:515
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [9]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:516
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [21]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:518
+assert_return(() => invoke($0, `dispatch-structural-f32`, [6]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:519
+assert_return(() => invoke($0, `dispatch-structural-f32`, [24]), [value("f32", 362880)]);
+
+// ./test/core/call_indirect.wast:520
+assert_return(() => invoke($0, `dispatch-structural-f32`, [27]), [value("f32", 55)]);
+
+// ./test/core/call_indirect.wast:521
+assert_return(() => invoke($0, `dispatch-structural-f32`, [21]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:522
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [8]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:523
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [19]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:525
+assert_return(() => invoke($0, `dispatch-structural-f64`, [7]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:526
+assert_return(() => invoke($0, `dispatch-structural-f64`, [25]), [value("f64", 362880)]);
+
+// ./test/core/call_indirect.wast:527
+assert_return(() => invoke($0, `dispatch-structural-f64`, [28]), [value("f64", 55)]);
+
+// ./test/core/call_indirect.wast:528
+assert_return(() => invoke($0, `dispatch-structural-f64`, [22]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:529
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [10]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:530
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [18]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:532
+assert_return(() => invoke($0, `fac-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:533
+assert_return(() => invoke($0, `fac-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:534
+assert_return(() => invoke($0, `fac-i64`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:535
+assert_return(() => invoke($0, `fac-i64`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/call_indirect.wast:537
+assert_return(() => invoke($0, `fac-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:538
+assert_return(() => invoke($0, `fac-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:539
+assert_return(() => invoke($0, `fac-i32`, [5]), [value("i32", 120)]);
+
+// ./test/core/call_indirect.wast:540
+assert_return(() => invoke($0, `fac-i32`, [10]), [value("i32", 3628800)]);
+
+// ./test/core/call_indirect.wast:542
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:543
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:544
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 5)]), [value("f32", 120)]);
+
+// ./test/core/call_indirect.wast:545
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 10)]), [value("f32", 3628800)]);
+
+// ./test/core/call_indirect.wast:547
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:548
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:549
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 5)]), [value("f64", 120)]);
+
+// ./test/core/call_indirect.wast:550
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 10)]), [value("f64", 3628800)]);
+
+// ./test/core/call_indirect.wast:552
+assert_return(() => invoke($0, `fib-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:553
+assert_return(() => invoke($0, `fib-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:554
+assert_return(() => invoke($0, `fib-i64`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:555
+assert_return(() => invoke($0, `fib-i64`, [5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:556
+assert_return(() => invoke($0, `fib-i64`, [20n]), [value("i64", 10946n)]);
+
+// ./test/core/call_indirect.wast:558
+assert_return(() => invoke($0, `fib-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:559
+assert_return(() => invoke($0, `fib-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:560
+assert_return(() => invoke($0, `fib-i32`, [2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:561
+assert_return(() => invoke($0, `fib-i32`, [5]), [value("i32", 8)]);
+
+// ./test/core/call_indirect.wast:562
+assert_return(() => invoke($0, `fib-i32`, [20]), [value("i32", 10946)]);
+
+// ./test/core/call_indirect.wast:564
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:565
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:566
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 2)]), [value("f32", 2)]);
+
+// ./test/core/call_indirect.wast:567
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 5)]), [value("f32", 8)]);
+
+// ./test/core/call_indirect.wast:568
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 20)]), [value("f32", 10946)]);
+
+// ./test/core/call_indirect.wast:570
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:571
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:572
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 2)]), [value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:573
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 5)]), [value("f64", 8)]);
+
+// ./test/core/call_indirect.wast:574
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 20)]), [value("f64", 10946)]);
+
+// ./test/core/call_indirect.wast:576
+assert_return(() => invoke($0, `even`, [0]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:577
+assert_return(() => invoke($0, `even`, [1]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:578
+assert_return(() => invoke($0, `even`, [100]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:579
+assert_return(() => invoke($0, `even`, [77]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:580
+assert_return(() => invoke($0, `odd`, [0]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:581
+assert_return(() => invoke($0, `odd`, [1]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:582
+assert_return(() => invoke($0, `odd`, [200]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:583
+assert_return(() => invoke($0, `odd`, [77]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:585
+assert_exhaustion(() => invoke($0, `runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:586
+assert_exhaustion(() => invoke($0, `mutual-runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:588
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:589
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:590
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:592
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:594
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:595
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:597
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:598
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:600
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/call_indirect.wast:601
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/call_indirect.wast:603
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:604
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:605
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/call_indirect.wast:606
+assert_return(() => invoke($0, `as-br-value`, []), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:607
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:608
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:609
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:610
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:612
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 0)]);
+
+// ./test/core/call_indirect.wast:613
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 11)]);
+
+// ./test/core/call_indirect.wast:614
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:615
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:616
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:617
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:618
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:623
+let $1 = instantiate(`(module
+  (type $$ii-i (func (param i32 i32) (result i32)))
+
+  (table $$t1 funcref (elem $$f $$g))
+  (table $$t2 funcref (elem $$h $$i $$j))
+  (table $$t3 4 funcref)
+  (elem (table $$t3) (i32.const 0) func $$g $$h)
+  (elem (table $$t3) (i32.const 3) func $$z)
+
+  (func $$f (type $$ii-i) (i32.add (local.get 0) (local.get 1)))
+  (func $$g (type $$ii-i) (i32.sub (local.get 0) (local.get 1)))
+  (func $$h (type $$ii-i) (i32.mul (local.get 0) (local.get 1)))
+  (func $$i (type $$ii-i) (i32.div_u (local.get 0) (local.get 1)))
+  (func $$j (type $$ii-i) (i32.rem_u (local.get 0) (local.get 1)))
+  (func $$z)
+
+  (func (export "call-1") (param i32 i32 i32) (result i32)
+    (call_indirect $$t1 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-2") (param i32 i32 i32) (result i32)
+    (call_indirect $$t2 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-3") (param i32 i32 i32) (result i32)
+    (call_indirect $$t3 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+)`);
+
+// ./test/core/call_indirect.wast:650
+assert_return(() => invoke($1, `call-1`, [2, 3, 0]), [value("i32", 5)]);
+
+// ./test/core/call_indirect.wast:651
+assert_return(() => invoke($1, `call-1`, [2, 3, 1]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:652
+assert_trap(() => invoke($1, `call-1`, [2, 3, 2]), `undefined element`);
+
+// ./test/core/call_indirect.wast:654
+assert_return(() => invoke($1, `call-2`, [2, 3, 0]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:655
+assert_return(() => invoke($1, `call-2`, [2, 3, 1]), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:656
+assert_return(() => invoke($1, `call-2`, [2, 3, 2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:657
+assert_trap(() => invoke($1, `call-2`, [2, 3, 3]), `undefined element`);
+
+// ./test/core/call_indirect.wast:659
+assert_return(() => invoke($1, `call-3`, [2, 3, 0]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:660
+assert_return(() => invoke($1, `call-3`, [2, 3, 1]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:661
+assert_trap(() => invoke($1, `call-3`, [2, 3, 2]), `uninitialized element`);
+
+// ./test/core/call_indirect.wast:662
+assert_trap(() => invoke($1, `call-3`, [2, 3, 3]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:663
+assert_trap(() => invoke($1, `call-3`, [2, 3, 4]), `undefined element`);
+
+// ./test/core/call_indirect.wast:668
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (param i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:680
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (param i32) (type $$sig) (result i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:692
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (param i32) (result i32) (type $$sig)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:704
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (result i32) (type $$sig) (param i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:716
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (result i32) (param i32) (type $$sig)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:728
+assert_malformed(
+  () => instantiate(`(table 0 funcref) (func (result i32)   (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:738
+assert_malformed(
+  () => instantiate(`(table 0 funcref) (func (call_indirect (param $$x i32) (i32.const 0) (i32.const 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:745
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:755
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:765
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func   (call_indirect (type $$sig) (param i32) (i32.const 0) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:775
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (param i32) (result i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:790
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (func $$no-table (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `unknown table`,
+);
+
+// ./test/core/call_indirect.wast:798
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:806
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $$type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:815
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:823
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $$arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:831
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:839
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$arity-2-vs-0
+      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:850
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:858
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:867
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $$type-first-void-vs-num
+      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:877
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $$type-second-void-vs-num
+      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:887
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $$type-first-num-vs-num
+      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:897
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $$type-second-num-vs-num
+      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:908
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-block
+      (block
+        (call_indirect (type $$sig) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:921
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-block
+      (block
+        (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:934
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-loop
+      (loop
+        (call_indirect (type $$sig) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:947
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-loop
+      (loop
+        (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:960
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $$sig) (i32.const 0))
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:976
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:996
+assert_invalid(
+  () => instantiate(`(module
+    (table 0 funcref)
+    (func $$unbound-type (call_indirect (type 1) (i32.const 0)))
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1003
+assert_invalid(
+  () => instantiate(`(module
+    (table 0 funcref)
+    (func $$large-type (call_indirect (type 1012321300) (i32.const 0)))
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1014
+assert_invalid(
+  () => instantiate(`(module (table funcref (elem 0 0)))`),
+  `unknown function`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js
new file mode 100644
index 0000000000..43b5fcf08d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/call_ref.wast.js
@@ -0,0 +1,144 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/call_ref.wast
+
+// ./test/core/call_ref.wast:1
+let $0 = instantiate(`(module
+  (type $$ii (func (param i32) (result i32)))
+
+  (func $$apply (param $$f (ref $$ii)) (param $$x i32) (result i32)
+    (call_ref $$ii (local.get $$x) (local.get $$f))
+  )
+
+  (func $$f (type $$ii) (i32.mul (local.get 0) (local.get 0)))
+  (func $$g (type $$ii) (i32.sub (i32.const 0) (local.get 0)))
+
+  (elem declare func $$f $$g)
+
+  (func (export "run") (param $$x i32) (result i32)
+    (local $$rf (ref null $$ii))
+    (local $$rg (ref null $$ii))
+    (local.set $$rf (ref.func $$f))
+    (local.set $$rg (ref.func $$g))
+    (call_ref $$ii (call_ref $$ii (local.get $$x) (local.get $$rf)) (local.get $$rg))
+  )
+
+  (func (export "null") (result i32)
+    (call_ref $$ii (i32.const 1) (ref.null $$ii))
+  )
+)`);
+
+// ./test/core/call_ref.wast:94
+assert_return(() => invoke($0, `run`, [0]), [value("i32", 0)]);
+
+// ./test/core/call_ref.wast:95
+assert_return(() => invoke($0, `run`, [3]), [value("i32", -9)]);
+
+// ./test/core/call_ref.wast:97
+assert_trap(() => invoke($0, `null`, []), `null function`);
+
+// ./test/core/call_ref.wast:129
+let $1 = instantiate(`(module
+  (type $$t (func))
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (call_ref $$t)
+  )
+)`);
+
+// ./test/core/call_ref.wast:136
+assert_trap(() => invoke($1, `unreachable`, []), `unreachable`);
+
+// ./test/core/call_ref.wast:138
+let $2 = instantiate(`(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 $$t)
+  )
+)`);
+
+// ./test/core/call_ref.wast:149
+assert_trap(() => invoke($2, `unreachable`, []), `unreachable`);
+
+// ./test/core/call_ref.wast:151
+let $3 = instantiate(`(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 $$t)
+    (drop)
+    (i32.const 0)
+  )
+)`);
+
+// ./test/core/call_ref.wast:165
+assert_trap(() => invoke($3, `unreachable`, []), `unreachable`);
+
+// ./test/core/call_ref.wast:167
+assert_invalid(
+  () => instantiate(`(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 $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_ref.wast:183
+assert_invalid(
+  () => instantiate(`(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 $$t)
+      (drop)
+      (i64.const 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_ref.wast:200
+assert_invalid(
+  () => instantiate(`(module
+    (type $$t (func))
+    (func $$f (param $$r externref)
+      (call_ref $$t (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/directives.txt b/js/src/jit-test/tests/wasm/spec/function-references/directives.txt
new file mode 100644
index 0000000000..bb76560525
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; --wasm-function-references; skip-if: !wasmFunctionReferencesEnabled()
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/func.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/func.wast.js
new file mode 100644
index 0000000000..8521cbbd18
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/func.wast.js
@@ -0,0 +1,1240 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/func.wast
+
+// ./test/core/func.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (type $$sig (func))
+  (func $$dummy)
+
+  ;; Syntax
+
+  (func)
+  (func (export "f"))
+  (func $$f)
+  (func $$h (export "g"))
+
+  (func (local))
+  (func (local) (local))
+  (func (local i32))
+  (func (local $$x i32))
+  (func (local i32 f64 i64))
+  (func (local i32) (local f64))
+  (func (local i32 f32) (local $$x i64) (local) (local i32 f64))
+
+  (func (param))
+  (func (param) (param))
+  (func (param i32))
+  (func (param $$x i32))
+  (func (param i32 f64 i64))
+  (func (param i32) (param f64))
+  (func (param i32 f32) (param $$x i64) (param) (param i32 f64))
+
+  (func (result))
+  (func (result) (result))
+  (func (result i32) (unreachable))
+  (func (result i32 f64 f32) (unreachable))
+  (func (result i32) (result f64) (unreachable))
+  (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable))
+
+  (type $$sig-1 (func))
+  (type $$sig-2 (func (result i32)))
+  (type $$sig-3 (func (param $$x i32)))
+  (type $$sig-4 (func (param i32 f64 i32) (result i32)))
+
+  (func (export "type-use-1") (type $$sig-1))
+  (func (export "type-use-2") (type $$sig-2) (i32.const 0))
+  (func (export "type-use-3") (type $$sig-3))
+  (func (export "type-use-4") (type $$sig-4) (i32.const 0))
+  (func (export "type-use-5") (type $$sig-2) (result i32) (i32.const 0))
+  (func (export "type-use-6") (type $$sig-3) (param i32))
+  (func (export "type-use-7")
+    (type $$sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0)
+  )
+
+  (func (type $$sig))
+  (func (type $$forward))  ;; forward reference
+
+  (func $$complex
+    (param i32 f32) (param $$x i64) (param) (param i32)
+    (result) (result i32) (result) (result i64 i32)
+    (local f32) (local $$y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+  (func $$complex-sig
+    (type $$sig)
+    (local f32) (local $$y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+
+  (type $$forward (func))
+
+  ;; Typing of locals
+
+  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
+  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
+  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
+  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
+  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
+  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
+  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
+  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
+  (func (export "local-mixed") (result f64)
+    (local f32) (local $$x i32) (local i64 i32) (local) (local f64 i32)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of parameters
+
+  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
+  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
+  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
+  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
+  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
+  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
+  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
+  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
+  (func (export "param-mixed") (param f32 i32) (param) (param $$x i64) (param i32 f64 i32)
+    (result f64)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of results
+
+  (func (export "empty"))
+  (func (export "value-void") (call $$dummy))
+  (func (export "value-i32") (result i32) (i32.const 77))
+  (func (export "value-i64") (result i64) (i64.const 7777))
+  (func (export "value-f32") (result f32) (f32.const 77.7))
+  (func (export "value-f64") (result f64) (f64.const 77.77))
+  (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7))
+  (func (export "value-i32-i32-i32") (result i32 i32 i32)
+    (i32.const 1) (i32.const 2) (i32.const 3)
+  )
+  (func (export "value-block-void") (block (call $$dummy) (call $$dummy)))
+  (func (export "value-block-i32") (result i32)
+    (block (result i32) (call $$dummy) (i32.const 77))
+  )
+  (func (export "value-block-i32-i64") (result i32 i64)
+    (block (result i32 i64) (call $$dummy) (i32.const 1) (i64.const 2))
+  )
+
+  (func (export "return-empty") (return))
+  (func (export "return-i32") (result i32) (return (i32.const 78)))
+  (func (export "return-i64") (result i64) (return (i64.const 7878)))
+  (func (export "return-f32") (result f32) (return (f32.const 78.7)))
+  (func (export "return-f64") (result f64) (return (f64.const 78.78)))
+  (func (export "return-i32-f64") (result i32 f64)
+    (return (i32.const 78) (f64.const 78.78))
+  )
+  (func (export "return-i32-i32-i32") (result i32 i32 i32)
+    (return (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "return-block-i32") (result i32)
+    (return (block (result i32) (call $$dummy) (i32.const 77)))
+  )
+  (func (export "return-block-i32-i64") (result i32 i64)
+    (return (block (result i32 i64) (call $$dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-empty") (br 0))
+  (func (export "break-i32") (result i32) (br 0 (i32.const 79)))
+  (func (export "break-i64") (result i64) (br 0 (i64.const 7979)))
+  (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
+  (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
+  (func (export "break-i32-f64") (result i32 f64)
+    (br 0 (i32.const 79) (f64.const 79.79))
+  )
+  (func (export "break-i32-i32-i32") (result i32 i32 i32)
+    (br 0 (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "break-block-i32") (result i32)
+    (br 0 (block (result i32) (call $$dummy) (i32.const 77)))
+  )
+  (func (export "break-block-i32-i64") (result i32 i64)
+    (br 0 (block (result i32 i64) (call $$dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-br_if-empty") (param i32)
+    (br_if 0 (local.get 0))
+  )
+  (func (export "break-br_if-num") (param i32) (result i32)
+    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
+  )
+  (func (export "break-br_if-num-num") (param i32) (result i32 i64)
+    (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0))))
+    (i32.const 51) (i64.const 52)
+  )
+
+  (func (export "break-br_table-empty") (param i32)
+    (br_table 0 0 0 (local.get 0))
+  )
+  (func (export "break-br_table-num") (param i32) (result i32)
+    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
+  )
+  (func (export "break-br_table-num-num") (param i32) (result f32 i64)
+    (br_table 0 0 (f32.const 50) (i64.const 51) (local.get 0))
+    (f32.const 51) (i64.const 52)
+  )
+  (func (export "break-br_table-nested-empty") (param i32)
+    (block (br_table 0 1 0 (local.get 0)))
+  )
+  (func (export "break-br_table-nested-num") (param i32) (result i32)
+    (i32.add
+      (block (result i32)
+        (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51)
+      )
+      (i32.const 2)
+    )
+  )
+  (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32)
+    (i32.add
+      (block (result i32 i32)
+        (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0))
+        (i32.const 51) (i32.const -3)
+      )
+    )
+    (i32.const 52)
+  )
+
+  ;; Large signatures
+
+  (func (export "large-sig")
+    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
+    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
+    (local.get 5)
+    (local.get 2)
+    (local.get 0)
+    (local.get 8)
+    (local.get 7)
+    (local.get 1)
+    (local.get 3)
+    (local.get 9)
+    (local.get 4)
+    (local.get 6)
+    (local.get 13)
+    (local.get 11)
+    (local.get 15)
+    (local.get 16)
+    (local.get 14)
+    (local.get 12)
+  )
+
+  ;; Default initialization of locals
+
+  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
+)`);
+
+// ./test/core/func.wast:241
+assert_return(() => invoke($0, `type-use-1`, []), []);
+
+// ./test/core/func.wast:242
+assert_return(() => invoke($0, `type-use-2`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:243
+assert_return(() => invoke($0, `type-use-3`, [1]), []);
+
+// ./test/core/func.wast:244
+assert_return(() => invoke($0, `type-use-4`, [1, value("f64", 1), 1]), [value("i32", 0)]);
+
+// ./test/core/func.wast:248
+assert_return(() => invoke($0, `type-use-5`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:249
+assert_return(() => invoke($0, `type-use-6`, [1]), []);
+
+// ./test/core/func.wast:250
+assert_return(() => invoke($0, `type-use-7`, [1, value("f64", 1), 1]), [value("i32", 0)]);
+
+// ./test/core/func.wast:255
+assert_return(() => invoke($0, `local-first-i32`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:256
+assert_return(() => invoke($0, `local-first-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/func.wast:257
+assert_return(() => invoke($0, `local-first-f32`, []), [value("f32", 0)]);
+
+// ./test/core/func.wast:258
+assert_return(() => invoke($0, `local-first-f64`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:259
+assert_return(() => invoke($0, `local-second-i32`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:260
+assert_return(() => invoke($0, `local-second-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/func.wast:261
+assert_return(() => invoke($0, `local-second-f32`, []), [value("f32", 0)]);
+
+// ./test/core/func.wast:262
+assert_return(() => invoke($0, `local-second-f64`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:263
+assert_return(() => invoke($0, `local-mixed`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:265
+assert_return(() => invoke($0, `param-first-i32`, [2, 3]), [value("i32", 2)]);
+
+// ./test/core/func.wast:268
+assert_return(() => invoke($0, `param-first-i64`, [2n, 3n]), [value("i64", 2n)]);
+
+// ./test/core/func.wast:271
+assert_return(
+  () => invoke($0, `param-first-f32`, [value("f32", 2), value("f32", 3)]),
+  [value("f32", 2)],
+);
+
+// ./test/core/func.wast:274
+assert_return(
+  () => invoke($0, `param-first-f64`, [value("f64", 2), value("f64", 3)]),
+  [value("f64", 2)],
+);
+
+// ./test/core/func.wast:277
+assert_return(() => invoke($0, `param-second-i32`, [2, 3]), [value("i32", 3)]);
+
+// ./test/core/func.wast:280
+assert_return(() => invoke($0, `param-second-i64`, [2n, 3n]), [value("i64", 3n)]);
+
+// ./test/core/func.wast:283
+assert_return(
+  () => invoke($0, `param-second-f32`, [value("f32", 2), value("f32", 3)]),
+  [value("f32", 3)],
+);
+
+// ./test/core/func.wast:286
+assert_return(
+  () => invoke($0, `param-second-f64`, [value("f64", 2), value("f64", 3)]),
+  [value("f64", 3)],
+);
+
+// ./test/core/func.wast:290
+assert_return(
+  () => invoke($0, `param-mixed`, [value("f32", 1), 2, 3n, 4, value("f64", 5.5), 6]),
+  [value("f64", 5.5)],
+);
+
+// ./test/core/func.wast:298
+assert_return(() => invoke($0, `empty`, []), []);
+
+// ./test/core/func.wast:299
+assert_return(() => invoke($0, `value-void`, []), []);
+
+// ./test/core/func.wast:300
+assert_return(() => invoke($0, `value-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:301
+assert_return(() => invoke($0, `value-i64`, []), [value("i64", 7777n)]);
+
+// ./test/core/func.wast:302
+assert_return(() => invoke($0, `value-f32`, []), [value("f32", 77.7)]);
+
+// ./test/core/func.wast:303
+assert_return(() => invoke($0, `value-f64`, []), [value("f64", 77.77)]);
+
+// ./test/core/func.wast:304
+assert_return(() => invoke($0, `value-i32-f64`, []), [value("i32", 77), value("f64", 7)]);
+
+// ./test/core/func.wast:305
+assert_return(
+  () => invoke($0, `value-i32-i32-i32`, []),
+  [value("i32", 1), value("i32", 2), value("i32", 3)],
+);
+
+// ./test/core/func.wast:308
+assert_return(() => invoke($0, `value-block-void`, []), []);
+
+// ./test/core/func.wast:309
+assert_return(() => invoke($0, `value-block-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:310
+assert_return(() => invoke($0, `value-block-i32-i64`, []), [value("i32", 1), value("i64", 2n)]);
+
+// ./test/core/func.wast:312
+assert_return(() => invoke($0, `return-empty`, []), []);
+
+// ./test/core/func.wast:313
+assert_return(() => invoke($0, `return-i32`, []), [value("i32", 78)]);
+
+// ./test/core/func.wast:314
+assert_return(() => invoke($0, `return-i64`, []), [value("i64", 7878n)]);
+
+// ./test/core/func.wast:315
+assert_return(() => invoke($0, `return-f32`, []), [value("f32", 78.7)]);
+
+// ./test/core/func.wast:316
+assert_return(() => invoke($0, `return-f64`, []), [value("f64", 78.78)]);
+
+// ./test/core/func.wast:317
+assert_return(() => invoke($0, `return-i32-f64`, []), [value("i32", 78), value("f64", 78.78)]);
+
+// ./test/core/func.wast:318
+assert_return(
+  () => invoke($0, `return-i32-i32-i32`, []),
+  [value("i32", 1), value("i32", 2), value("i32", 3)],
+);
+
+// ./test/core/func.wast:321
+assert_return(() => invoke($0, `return-block-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:322
+assert_return(() => invoke($0, `return-block-i32-i64`, []), [value("i32", 1), value("i64", 2n)]);
+
+// ./test/core/func.wast:324
+assert_return(() => invoke($0, `break-empty`, []), []);
+
+// ./test/core/func.wast:325
+assert_return(() => invoke($0, `break-i32`, []), [value("i32", 79)]);
+
+// ./test/core/func.wast:326
+assert_return(() => invoke($0, `break-i64`, []), [value("i64", 7979n)]);
+
+// ./test/core/func.wast:327
+assert_return(() => invoke($0, `break-f32`, []), [value("f32", 79.9)]);
+
+// ./test/core/func.wast:328
+assert_return(() => invoke($0, `break-f64`, []), [value("f64", 79.79)]);
+
+// ./test/core/func.wast:329
+assert_return(() => invoke($0, `break-i32-f64`, []), [value("i32", 79), value("f64", 79.79)]);
+
+// ./test/core/func.wast:330
+assert_return(
+  () => invoke($0, `break-i32-i32-i32`, []),
+  [value("i32", 1), value("i32", 2), value("i32", 3)],
+);
+
+// ./test/core/func.wast:333
+assert_return(() => invoke($0, `break-block-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:334
+assert_return(() => invoke($0, `break-block-i32-i64`, []), [value("i32", 1), value("i64", 2n)]);
+
+// ./test/core/func.wast:336
+assert_return(() => invoke($0, `break-br_if-empty`, [0]), []);
+
+// ./test/core/func.wast:337
+assert_return(() => invoke($0, `break-br_if-empty`, [2]), []);
+
+// ./test/core/func.wast:338
+assert_return(() => invoke($0, `break-br_if-num`, [0]), [value("i32", 51)]);
+
+// ./test/core/func.wast:339
+assert_return(() => invoke($0, `break-br_if-num`, [1]), [value("i32", 50)]);
+
+// ./test/core/func.wast:340
+assert_return(() => invoke($0, `break-br_if-num-num`, [0]), [value("i32", 51), value("i64", 52n)]);
+
+// ./test/core/func.wast:343
+assert_return(() => invoke($0, `break-br_if-num-num`, [1]), [value("i32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:347
+assert_return(() => invoke($0, `break-br_table-empty`, [0]), []);
+
+// ./test/core/func.wast:348
+assert_return(() => invoke($0, `break-br_table-empty`, [1]), []);
+
+// ./test/core/func.wast:349
+assert_return(() => invoke($0, `break-br_table-empty`, [5]), []);
+
+// ./test/core/func.wast:350
+assert_return(() => invoke($0, `break-br_table-empty`, [-1]), []);
+
+// ./test/core/func.wast:351
+assert_return(() => invoke($0, `break-br_table-num`, [0]), [value("i32", 50)]);
+
+// ./test/core/func.wast:352
+assert_return(() => invoke($0, `break-br_table-num`, [1]), [value("i32", 50)]);
+
+// ./test/core/func.wast:353
+assert_return(() => invoke($0, `break-br_table-num`, [10]), [value("i32", 50)]);
+
+// ./test/core/func.wast:354
+assert_return(() => invoke($0, `break-br_table-num`, [-100]), [value("i32", 50)]);
+
+// ./test/core/func.wast:355
+assert_return(() => invoke($0, `break-br_table-num-num`, [0]), [value("f32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:358
+assert_return(() => invoke($0, `break-br_table-num-num`, [1]), [value("f32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:361
+assert_return(() => invoke($0, `break-br_table-num-num`, [10]), [value("f32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:364
+assert_return(() => invoke($0, `break-br_table-num-num`, [-100]), [value("f32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:367
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [0]), []);
+
+// ./test/core/func.wast:368
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [1]), []);
+
+// ./test/core/func.wast:369
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [3]), []);
+
+// ./test/core/func.wast:370
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [-2]), []);
+
+// ./test/core/func.wast:371
+assert_return(() => invoke($0, `break-br_table-nested-num`, [0]), [value("i32", 52)]);
+
+// ./test/core/func.wast:374
+assert_return(() => invoke($0, `break-br_table-nested-num`, [1]), [value("i32", 50)]);
+
+// ./test/core/func.wast:377
+assert_return(() => invoke($0, `break-br_table-nested-num`, [2]), [value("i32", 52)]);
+
+// ./test/core/func.wast:380
+assert_return(() => invoke($0, `break-br_table-nested-num`, [-3]), [value("i32", 52)]);
+
+// ./test/core/func.wast:383
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [0]),
+  [value("i32", 101), value("i32", 52)],
+);
+
+// ./test/core/func.wast:387
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [1]),
+  [value("i32", 50), value("i32", 51)],
+);
+
+// ./test/core/func.wast:391
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [2]),
+  [value("i32", 101), value("i32", 52)],
+);
+
+// ./test/core/func.wast:395
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [-3]),
+  [value("i32", 101), value("i32", 52)],
+);
+
+// ./test/core/func.wast:400
+assert_return(
+  () => invoke($0, `large-sig`, [
+    0,
+    1n,
+    value("f32", 2),
+    value("f32", 3),
+    4,
+    value("f64", 5),
+    value("f32", 6),
+    7,
+    8,
+    9,
+    value("f32", 10),
+    value("f64", 11),
+    value("f64", 12),
+    value("f64", 13),
+    14,
+    15,
+    value("f32", 16),
+  ]),
+  [
+    value("f64", 5),
+    value("f32", 2),
+    value("i32", 0),
+    value("i32", 8),
+    value("i32", 7),
+    value("i64", 1n),
+    value("f32", 3),
+    value("i32", 9),
+    value("i32", 4),
+    value("f32", 6),
+    value("f64", 13),
+    value("f64", 11),
+    value("i32", 15),
+    value("f32", 16),
+    value("i32", 14),
+    value("f64", 12),
+  ],
+);
+
+// ./test/core/func.wast:414
+assert_return(() => invoke($0, `init-local-i32`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:415
+assert_return(() => invoke($0, `init-local-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/func.wast:416
+assert_return(() => invoke($0, `init-local-f32`, []), [value("f32", 0)]);
+
+// ./test/core/func.wast:417
+assert_return(() => invoke($0, `init-local-f64`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:422
+let $1 = instantiate(`(module
+  (func $$f (result f64) (f64.const 0))  ;; adds implicit type definition
+  (func $$g (param i32))                 ;; reuses explicit type definition
+  (type $$t (func (param i32)))
+
+  (func $$i32->void (type 0))                ;; (param i32)
+  (func $$void->f64 (type 1) (f64.const 0))  ;; (result f64)
+  (func $$check
+    (call $$i32->void (i32.const 0))
+    (drop (call $$void->f64))
+  )
+)`);
+
+// ./test/core/func.wast:435
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (result f64) (f64.const 0))  ;; adds implicit type definition
+    (func $$g (param i32))                 ;; reuses explicit type definition
+    (func $$h (result f64) (f64.const 1))  ;; reuses implicit type definition
+    (type $$t (func (param i32)))
+
+    (func (type 2))  ;; does not exist
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/func.wast:447
+assert_malformed(
+  () => instantiate(`(func $$f (result f64) (f64.const 0)) (func $$g (param i32)) (func $$h (result f64) (f64.const 1)) (type $$t (func (param i32))) (func (type 2) (param i32)) `),
+  `unknown type`,
+);
+
+// ./test/core/func.wast:459
+let $2 = instantiate(`(module
+  (type $$proc (func (result i32)))
+  (type $$sig (func (param i32) (result i32)))
+
+  (func (export "f") (type $$sig)
+    (local $$var i32)
+    (local.get $$var)
+  )
+
+  (func $$g (type $$sig)
+    (local $$var i32)
+    (local.get $$var)
+  )
+  (func (export "g") (type $$sig)
+    (call $$g (local.get 0))
+  )
+
+  (func (export "p") (type $$proc)
+    (local $$var i32)
+    (local.set 0 (i32.const 42))
+    (local.get $$var)
+  )
+)`);
+
+// ./test/core/func.wast:483
+assert_return(() => invoke($2, `f`, [42]), [value("i32", 0)]);
+
+// ./test/core/func.wast:484
+assert_return(() => invoke($2, `g`, [42]), [value("i32", 0)]);
+
+// ./test/core/func.wast:485
+assert_return(() => invoke($2, `p`, []), [value("i32", 42)]);
+
+// ./test/core/func.wast:488
+let $3 = instantiate(`(module
+  (type $$sig (func))
+
+  (func $$empty-sig-1)  ;; should be assigned type $$sig
+  (func $$complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$empty-sig-2)  ;; should be assigned type $$sig
+  (func $$complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32))
+
+  (type $$empty-sig-duplicate (func))
+  (type $$complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
+  (table funcref
+    (elem
+      $$complex-sig-3 $$empty-sig-2 $$complex-sig-1 $$complex-sig-3 $$empty-sig-1
+      $$complex-sig-4 $$complex-sig-5
+    )
+  )
+
+  (func (export "signature-explicit-reused")
+    (call_indirect (type $$sig) (i32.const 1))
+    (call_indirect (type $$sig) (i32.const 4))
+  )
+
+  (func (export "signature-implicit-reused")
+    ;; The implicit index 3 in this test depends on the function and
+    ;; type definitions, and may need adapting if they change.
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 0)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 2)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 3)
+    )
+  )
+
+  (func (export "signature-explicit-duplicate")
+    (call_indirect (type $$empty-sig-duplicate) (i32.const 1))
+  )
+
+  (func (export "signature-implicit-duplicate")
+    (call_indirect (type $$complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 5)
+    )
+    (call_indirect (type $$complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 6)
+    )
+  )
+)`);
+
+// ./test/core/func.wast:551
+assert_return(() => invoke($3, `signature-explicit-reused`, []), []);
+
+// ./test/core/func.wast:552
+assert_return(() => invoke($3, `signature-implicit-reused`, []), []);
+
+// ./test/core/func.wast:553
+assert_return(() => invoke($3, `signature-explicit-duplicate`, []), []);
+
+// ./test/core/func.wast:554
+assert_return(() => invoke($3, `signature-implicit-duplicate`, []), []);
+
+// ./test/core/func.wast:559
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (type $$sig) (result i32) (param i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:566
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (param i32) (type $$sig) (result i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:573
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (param i32) (result i32) (type $$sig) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:580
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (result i32) (type $$sig) (param i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:587
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (result i32) (param i32) (type $$sig) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:594
+assert_malformed(
+  () => instantiate(`(func (result i32) (param i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:601
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (func (type $$sig) (result i32) (i32.const 0)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:608
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (type $$sig) (result i32) (i32.const 0)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:615
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (type $$sig) (param i32) (i32.const 0)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:622
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (func (type $$sig) (param i32) (result i32) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:630
+assert_invalid(() => instantiate(`(module (func $$g (type 4)))`), `unknown type`);
+
+// ./test/core/func.wast:634
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (drop (ref.func $$g)))
+    (func $$g (type 4))
+    (elem declare func $$g)
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/func.wast:646
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i64) (local i32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:650
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:654
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:659
+assert_invalid(
+  () => instantiate(`(module
+    (type $$t (func))
+    (func $$type-local-uninitialized (local $$x (ref $$t)) (drop (local.get $$x)))
+  )`),
+  `uninitialized local`,
+);
+
+// ./test/core/func.wast:670
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param i32) (result i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:674
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:678
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:686
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:690
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:694
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:698
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:702
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64-i32 (result f64 i32)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:707
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-num (result i32)
+    (nop)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:713
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-nums (result i32 i32)
+    (nop)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:719
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-void
+    (i32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:725
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-void
+    (i32.const 0) (i64.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:731
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-num (result i32)
+    (f32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:737
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-nums (result f32 f32)
+    (f32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:743
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-num (result f32)
+    (f32.const 0) (f32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:750
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-empty-vs-num (result i32)
+    (return)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:756
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-empty-vs-nums (result i32 i32)
+    (return)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:762
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-void-vs-num (result i32)
+    (return (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:768
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-void-vs-nums (result i32 i64)
+    (return (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:774
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-num-vs-num (result i32)
+    (return (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:780
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-num-vs-nums (result i64 i64)
+    (return (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:787
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-empty-vs-num (result i32)
+    (return) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:793
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-empty-vs-nums (result i32 i32)
+    (return) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:799
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-partial-vs-nums (result i32 i32)
+    (i32.const 1) (return) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:805
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-void-vs-num (result i32)
+    (return (nop)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:811
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-void-vs-nums (result i32 i32)
+    (return (nop)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:817
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-num-vs-num (result i32)
+    (return (i64.const 1)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:823
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-num-vs-nums (result i32 i32)
+    (return (i64.const 1)) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:829
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-first-num-vs-num (result i32)
+    (return (i64.const 1)) (return (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:835
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-first-num-vs-nums (result i32 i32)
+    (return (i32.const 1)) (return (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:842
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-num (result i32)
+    (br 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:848
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-nums (result i32 i32)
+    (br 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:854
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-num-vs-num (result i32)
+    (br 0 (f32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:860
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:866
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-num (result i32)
+    (br 0) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:872
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-nums (result i32 i32)
+    (br 0) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:878
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:884
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 1)) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:890
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:897
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-num (result i32)
+    (block (br 1)) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:903
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-nums (result i32 i32)
+    (block (br 1)) (br 0 (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:909
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-num (result i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:915
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-nums (result i32 i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:921
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-num-vs-num (result i32)
+    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:927
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:937
+assert_malformed(() => instantiate(`(func (nop) (local i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:941
+assert_malformed(() => instantiate(`(func (nop) (param i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:945
+assert_malformed(() => instantiate(`(func (nop) (result i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:949
+assert_malformed(() => instantiate(`(func (local i32) (param i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:953
+assert_malformed(
+  () => instantiate(`(func (local i32) (result i32) (local.get 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:957
+assert_malformed(
+  () => instantiate(`(func (result i32) (param i32) (local.get 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:964
+assert_malformed(() => instantiate(`(func $$foo) (func $$foo) `), `duplicate func`);
+
+// ./test/core/func.wast:968
+assert_malformed(
+  () => instantiate(`(import "" "" (func $$foo)) (func $$foo) `),
+  `duplicate func`,
+);
+
+// ./test/core/func.wast:972
+assert_malformed(
+  () => instantiate(`(import "" "" (func $$foo)) (import "" "" (func $$foo)) `),
+  `duplicate func`,
+);
+
+// ./test/core/func.wast:977
+assert_malformed(
+  () => instantiate(`(func (param $$foo i32) (param $$foo i32)) `),
+  `duplicate local`,
+);
+
+// ./test/core/func.wast:981
+assert_malformed(
+  () => instantiate(`(func (param $$foo i32) (local $$foo i32)) `),
+  `duplicate local`,
+);
+
+// ./test/core/func.wast:985
+assert_malformed(
+  () => instantiate(`(func (local $$foo i32) (local $$foo i32)) `),
+  `duplicate local`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/global.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/global.wast.js
new file mode 100644
index 0000000000..858c32e39c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/global.wast.js
@@ -0,0 +1,808 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/global.wast
+
+// ./test/core/global.wast:3
+let $0 = instantiate(`(module
+  (global (import "spectest" "global_i32") i32)
+  (global (import "spectest" "global_i64") i64)
+
+  (global $$a i32 (i32.const -2))
+  (global (;3;) f32 (f32.const -3))
+  (global (;4;) f64 (f64.const -4))
+  (global $$b i64 (i64.const -5))
+
+  (global $$x (mut i32) (i32.const -12))
+  (global (;7;) (mut f32) (f32.const -13))
+  (global (;8;) (mut f64) (f64.const -14))
+  (global $$y (mut i64) (i64.const -15))
+
+  (global $$z1 i32 (global.get 0))
+  (global $$z2 i64 (global.get 1))
+
+  (global $$r externref (ref.null extern))
+  (global $$mr (mut externref) (ref.null extern))
+  (global funcref (ref.null func))
+
+  (func (export "get-a") (result i32) (global.get $$a))
+  (func (export "get-b") (result i64) (global.get $$b))
+  (func (export "get-r") (result externref) (global.get $$r))
+  (func (export "get-mr") (result externref) (global.get $$mr))
+  (func (export "get-x") (result i32) (global.get $$x))
+  (func (export "get-y") (result i64) (global.get $$y))
+  (func (export "get-z1") (result i32) (global.get $$z1))
+  (func (export "get-z2") (result i64) (global.get $$z2))
+  (func (export "set-x") (param i32) (global.set $$x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $$y (local.get 0)))
+  (func (export "set-mr") (param externref) (global.set $$mr (local.get 0)))
+
+  (func (export "get-3") (result f32) (global.get 3))
+  (func (export "get-4") (result f64) (global.get 4))
+  (func (export "get-7") (result f32) (global.get 7))
+  (func (export "get-8") (result f64) (global.get 8))
+  (func (export "set-7") (param f32) (global.set 7 (local.get 0)))
+  (func (export "set-8") (param f64) (global.set 8 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (global.get $$x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (global.get $$x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (global.get $$x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $$x) (call $$dummy) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $$dummy) (global.get $$x) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $$dummy) (call $$dummy) (global.get $$x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $$x)
+      (then (call $$dummy) (i32.const 2))
+      (else (call $$dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $$x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $$x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $$x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $$x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $$x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $$x) (br_table 0 0)
+    )
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (global.get $$x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (global.get $$x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (i32.const 0) (global.get $$x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $$x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $$x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $$x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (global.get $$x))
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $$f (global.get $$x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $$x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (global.get $$x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $$x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $$x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $$x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$x (global.get $$x))
+    (global.get $$x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $$x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $$x) (global.get $$x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+)`);
+
+// ./test/core/global.wast:196
+assert_return(() => invoke($0, `get-a`, []), [value("i32", -2)]);
+
+// ./test/core/global.wast:197
+assert_return(() => invoke($0, `get-b`, []), [value("i64", -5n)]);
+
+// ./test/core/global.wast:198
+assert_return(() => invoke($0, `get-r`, []), [value('externref', null)]);
+
+// ./test/core/global.wast:199
+assert_return(() => invoke($0, `get-mr`, []), [value('externref', null)]);
+
+// ./test/core/global.wast:200
+assert_return(() => invoke($0, `get-x`, []), [value("i32", -12)]);
+
+// ./test/core/global.wast:201
+assert_return(() => invoke($0, `get-y`, []), [value("i64", -15n)]);
+
+// ./test/core/global.wast:202
+assert_return(() => invoke($0, `get-z1`, []), [value("i32", 666)]);
+
+// ./test/core/global.wast:203
+assert_return(() => invoke($0, `get-z2`, []), [value("i64", 666n)]);
+
+// ./test/core/global.wast:205
+assert_return(() => invoke($0, `get-3`, []), [value("f32", -3)]);
+
+// ./test/core/global.wast:206
+assert_return(() => invoke($0, `get-4`, []), [value("f64", -4)]);
+
+// ./test/core/global.wast:207
+assert_return(() => invoke($0, `get-7`, []), [value("f32", -13)]);
+
+// ./test/core/global.wast:208
+assert_return(() => invoke($0, `get-8`, []), [value("f64", -14)]);
+
+// ./test/core/global.wast:210
+assert_return(() => invoke($0, `set-x`, [6]), []);
+
+// ./test/core/global.wast:211
+assert_return(() => invoke($0, `set-y`, [7n]), []);
+
+// ./test/core/global.wast:213
+assert_return(() => invoke($0, `set-7`, [value("f32", 8)]), []);
+
+// ./test/core/global.wast:214
+assert_return(() => invoke($0, `set-8`, [value("f64", 9)]), []);
+
+// ./test/core/global.wast:216
+assert_return(() => invoke($0, `get-x`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:217
+assert_return(() => invoke($0, `get-y`, []), [value("i64", 7n)]);
+
+// ./test/core/global.wast:218
+assert_return(() => invoke($0, `get-7`, []), [value("f32", 8)]);
+
+// ./test/core/global.wast:219
+assert_return(() => invoke($0, `get-8`, []), [value("f64", 9)]);
+
+// ./test/core/global.wast:221
+assert_return(() => invoke($0, `set-7`, [value("f32", 8)]), []);
+
+// ./test/core/global.wast:222
+assert_return(() => invoke($0, `set-8`, [value("f64", 9)]), []);
+
+// ./test/core/global.wast:223
+assert_return(() => invoke($0, `set-mr`, [externref(10)]), []);
+
+// ./test/core/global.wast:225
+assert_return(() => invoke($0, `get-x`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:226
+assert_return(() => invoke($0, `get-y`, []), [value("i64", 7n)]);
+
+// ./test/core/global.wast:227
+assert_return(() => invoke($0, `get-7`, []), [value("f32", 8)]);
+
+// ./test/core/global.wast:228
+assert_return(() => invoke($0, `get-8`, []), [value("f64", 9)]);
+
+// ./test/core/global.wast:229
+assert_return(() => invoke($0, `get-mr`, []), [value('externref', externref(10))]);
+
+// ./test/core/global.wast:231
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:232
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:233
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:235
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:236
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:237
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:239
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:240
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:241
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:243
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:244
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:246
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:247
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:249
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:250
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:251
+assert_trap(() => invoke($0, `as-call_indirect-last`, []), `undefined element`);
+
+// ./test/core/global.wast:253
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/global.wast:254
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/global.wast:255
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:256
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:258
+assert_return(() => invoke($0, `as-call-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:260
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:261
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/global.wast:262
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:264
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 6)]);
+
+// ./test/core/global.wast:265
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 6)]);
+
+// ./test/core/global.wast:266
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:268
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 0)]);
+
+// ./test/core/global.wast:269
+assert_return(() => invoke($0, `as-binary-operand`, []), [value("i32", 36)]);
+
+// ./test/core/global.wast:270
+assert_return(() => invoke($0, `as-compare-operand`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:272
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))`),
+  `immutable global`,
+);
+
+// ./test/core/global.wast:277
+assert_invalid(
+  () => instantiate(`(module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1))))`),
+  `immutable global`,
+);
+
+// ./test/core/global.wast:283
+let $1 = instantiate(`(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))`);
+
+// ./test/core/global.wast:284
+let $2 = instantiate(`(module (global (export "a") (mut f32) (f32.const 0)))`);
+
+// ./test/core/global.wast:286
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.neg (f32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:291
+assert_invalid(
+  () => instantiate(`(module (global f32 (local.get 0)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:296
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.neg (f32.const 1))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:301
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0) (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:306
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.ctz (i32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:311
+assert_invalid(
+  () => instantiate(`(module (global i32 (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:316
+assert_invalid(() => instantiate(`(module (global i32 (f32.const 0)))`), `type mismatch`);
+
+// ./test/core/global.wast:321
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0) (i32.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:326
+assert_invalid(
+  () => instantiate(`(module (global i32 (;empty instruction sequence;)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:331
+assert_invalid(
+  () => instantiate(`(module (global (import "" "") externref) (global funcref (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:336
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (global.get 0) (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:341
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (i32.const 0) (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:346
+assert_invalid(
+  () => instantiate(`(module (global i32 (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:351
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0)) (global i32 (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:355
+assert_invalid(
+  () => instantiate(`(module (global $$g i32 (i32.const 0)) (global i32 (global.get $$g)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:360
+assert_invalid(
+  () => instantiate(`(module (global i32 (global.get 1)) (global i32 (i32.const 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:365
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (global.get 2)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:370
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-mut-i32") (mut i32)) (global i32 (global.get 0)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:375
+let $3 = instantiate(`(module
+  (import "spectest" "global_i32" (global i32))
+)`);
+
+// ./test/core/global.wast:378
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\98\\80\\80\\80\\00"             ;; import section
+      "\\01"                          ;; length 1
+      "\\08\\73\\70\\65\\63\\74\\65\\73\\74"  ;; "spectest"
+      "\\0a\\67\\6c\\6f\\62\\61\\6c\\5f\\69\\33\\32" ;; "global_i32"
+      "\\03"                          ;; GlobalImport
+      "\\7f"                          ;; i32
+      "\\02"                          ;; malformed mutability
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:391
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\98\\80\\80\\80\\00"             ;; import section
+      "\\01"                          ;; length 1
+      "\\08\\73\\70\\65\\63\\74\\65\\73\\74"  ;; "spectest"
+      "\\0a\\67\\6c\\6f\\62\\61\\6c\\5f\\69\\33\\32" ;; "global_i32"
+      "\\03"                          ;; GlobalImport
+      "\\7f"                          ;; i32
+      "\\ff"                          ;; malformed mutability
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:405
+let $4 = instantiate(`(module
+  (global i32 (i32.const 0))
+)`);
+
+// ./test/core/global.wast:408
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\06\\86\\80\\80\\80\\00"  ;; global section
+      "\\01"               ;; length 1
+      "\\7f"               ;; i32
+      "\\02"               ;; malformed mutability
+      "\\41\\00"            ;; i32.const 0
+      "\\0b"               ;; end
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:420
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\06\\86\\80\\80\\80\\00"  ;; global section
+      "\\01"               ;; length 1
+      "\\7f"               ;; i32
+      "\\ff"               ;; malformed mutability
+      "\\41\\00"            ;; i32.const 0
+      "\\0b"               ;; end
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:434
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:439
+assert_invalid(
+  () => instantiate(`(module
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:447
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (func (result i32) (global.get 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:455
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 2))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:465
+assert_invalid(
+  () => instantiate(`(module (func (i32.const 0) (global.set 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:470
+assert_invalid(
+  () => instantiate(`(module
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:478
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (func (i32.const 0) (global.set 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:486
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 2))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:496
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty
+      (global.set $$x)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:505
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-block
+      (i32.const 0)
+      (block (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:515
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-loop
+      (i32.const 0)
+      (loop (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:525
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:535
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:545
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:555
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:565
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:575
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-return
+      (return (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:584
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-select
+      (select (global.set $$x) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:593
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-call
+      (call 1 (global.set $$x))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:603
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-global.set-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (global.set $$x) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:622
+assert_malformed(
+  () => instantiate(`(global $$foo i32 (i32.const 0)) (global $$foo i32 (i32.const 0)) `),
+  `duplicate global`,
+);
+
+// ./test/core/global.wast:626
+assert_malformed(
+  () => instantiate(`(import "" "" (global $$foo i32)) (global $$foo i32 (i32.const 0)) `),
+  `duplicate global`,
+);
+
+// ./test/core/global.wast:630
+assert_malformed(
+  () => instantiate(`(import "" "" (global $$foo i32)) (import "" "" (global $$foo i32)) `),
+  `duplicate global`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/function-references/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/harness/harness.js b/js/src/jit-test/tests/wasm/spec/function-references/harness/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/harness/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: 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",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/if.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/if.wast.js
new file mode 100644
index 0000000000..ada0bd224a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/if.wast.js
@@ -0,0 +1,1911 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/if.wast
+
+// ./test/core/if.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "empty") (param i32)
+    (if (local.get 0) (then))
+    (if (local.get 0) (then) (else))
+    (if $$l (local.get 0) (then))
+    (if $$l (local.get 0) (then) (else))
+  )
+
+  (func (export "singular") (param i32) (result i32)
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
+  )
+
+  (func (export "multi") (param i32) (result i32 i32)
+    (if (local.get 0) (then (call $$dummy) (call $$dummy) (call $$dummy)))
+    (if (local.get 0) (then) (else (call $$dummy) (call $$dummy) (call $$dummy)))
+    (if (result i32) (local.get 0)
+      (then (call $$dummy) (call $$dummy) (i32.const 8) (call $$dummy))
+      (else (call $$dummy) (call $$dummy) (i32.const 9) (call $$dummy))
+    )
+    (if (result i32 i64 i32) (local.get 0)
+      (then
+        (call $$dummy) (call $$dummy) (i32.const 1) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i64.const 2) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i32.const 3) (call $$dummy)
+      )
+      (else
+        (call $$dummy) (call $$dummy) (i32.const -1) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i64.const -2) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i32.const -3) (call $$dummy)
+      )
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $$dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $$dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $$dummy) (i32.const 9))
+          (else (call $$dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $$dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $$dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $$dummy) (i32.const 10))
+          (else (call $$dummy) (i32.const 11))
+        )
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (i32.const 3)
+    )
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select
+      (i32.const 2) (i32.const 3)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (call $$dummy) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32)
+      (call $$dummy)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (call $$dummy)
+    )
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32)
+      (call $$dummy) (call $$dummy)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (local.get 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $$dummy) (i32.const 2))
+      (else (call $$dummy) (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+        (i32.const 2)
+      )
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (i32.const 2)
+      (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32)
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (br_table 0 0)
+    )
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+        (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+        (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (i32.const 0)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (if (result i32) (local.get 0)
+      (then (call $$dummy) (i32.const 1))
+      (else (call $$dummy) (i32.const 0))
+    )
+    (i32.const 2)
+    (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 2)
+    (if (result i32) (local.get 0)
+      (then (call $$dummy) (i32.const 1))
+      (else (call $$dummy) (i32.const 0))
+    )
+    (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $$f
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (i32.const 1))
+      (else (i32.const 0)))
+    (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32)
+      (br 0
+        (if (result i32) (local.get 0)
+          (then (i32.const 1))
+          (else (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (local.set 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $$a
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    ) (global.get $$a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load
+      (if (result i32) (local.get 0)
+        (then (i32.const 11))
+        (else (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.ctz
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 13))
+        (else (call $$dummy) (i32.const -13))
+      )
+    )
+  )
+  (func (export "as-binary-operand") (param i32 i32) (result i32)
+    (i32.mul
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 3))
+        (else (call $$dummy) (i32.const -3))
+      )
+      (if (result i32) (local.get 1)
+        (then (call $$dummy) (i32.const 4))
+        (else (call $$dummy) (i32.const -5))
+      )
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 13))
+        (else (call $$dummy) (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-compare-operand") (param i32 i32) (result i32)
+    (f32.gt
+      (if (result f32) (local.get 0)
+        (then (call $$dummy) (f32.const 3))
+        (else (call $$dummy) (f32.const -3))
+      )
+      (if (result f32) (local.get 1)
+        (then (call $$dummy) (f32.const 4))
+        (else (call $$dummy) (f32.const -4))
+      )
+    )
+  )
+  (func (export "as-binary-operands") (param i32) (result i32)
+    (i32.mul
+      (if (result i32 i32) (local.get 0)
+        (then (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4))
+        (else (call $$dummy) (i32.const 3) (call $$dummy) (i32.const -4))
+      )
+    )
+  )
+  (func (export "as-compare-operands") (param i32) (result i32)
+    (f32.gt
+      (if (result f32 f32) (local.get 0)
+        (then (call $$dummy) (f32.const 3) (call $$dummy) (f32.const 3))
+        (else (call $$dummy) (f32.const -2) (call $$dummy) (f32.const -3))
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (param i32) (result i32)
+    (if (result i32 i32) (local.get 0)
+      (then (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4))
+      (else (call $$dummy) (i32.const -3) (call $$dummy) (i32.const -4))
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (if (i32.const 1) (then (br 0) (unreachable)))
+    (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable)))
+    (i32.const 19)
+  )
+
+  (func (export "break-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (br 0 (i32.const 18)) (i32.const 19))
+      (else (br 0 (i32.const 21)) (i32.const 20))
+    )
+  )
+  (func (export "break-multi-value") (param i32) (result i32 i32 i64)
+    (if (result i32 i32 i64) (local.get 0)
+      (then
+        (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+        (i32.const 19) (i32.const -19) (i64.const 19)
+      )
+      (else
+        (br 0 (i32.const -18) (i32.const 18) (i64.const -18))
+        (i32.const -19) (i32.const 19) (i64.const -19)
+      )
+    )
+  )
+
+  (func (export "param") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add))
+      (else (i32.const -2) (i32.add))
+    )
+  )
+  (func (export "params") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add))
+      (else (i32.sub))
+    )
+  )
+  (func (export "params-id") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then))
+    (i32.add)
+  )
+  (func (export "param-break") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add) (br 0))
+      (else (i32.const -2) (i32.add) (br 0))
+    )
+  )
+  (func (export "params-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add) (br 0))
+      (else (i32.sub) (br 0))
+    )
+  )
+  (func (export "params-id-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0)))
+    (i32.add)
+  )
+
+  (func (export "effects") (param i32) (result i32)
+    (local i32)
+    (if
+      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
+      (then
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
+      )
+      (else
+        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Examples
+
+  (func $$add64_u_with_carry (export "add64_u_with_carry")
+    (param $$i i64) (param $$j i64) (param $$c i32) (result i64 i32)
+    (local $$k i64)
+    (local.set $$k
+      (i64.add
+        (i64.add (local.get $$i) (local.get $$j))
+        (i64.extend_i32_u (local.get $$c))
+      )
+    )
+    (return (local.get $$k) (i64.lt_u (local.get $$k) (local.get $$i)))
+  )
+
+  (func $$add64_u_saturated (export "add64_u_saturated")
+    (param i64 i64) (result i64)
+    (call $$add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0))
+    (if (param i64) (result i64)
+      (then (drop) (i64.const -1))
+    )
+  )
+
+  ;; Block signature syntax
+
+  (type $$block-sig-1 (func))
+  (type $$block-sig-2 (func (result i32)))
+  (type $$block-sig-3 (func (param $$x i32)))
+  (type $$block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (if (type $$block-sig-1) (i32.const 1) (then))
+    (if (type $$block-sig-2) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $$block-sig-3) (i32.const 1) (then (drop)) (else (drop)))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $$block-sig-4) (i32.const 1) (then))
+    (drop) (drop) (drop)
+    (if (type $$block-sig-2) (result i32) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $$block-sig-3) (param i32) (i32.const 1)
+      (then (drop)) (else (drop))
+    )
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $$block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+      (i32.const 1) (then)
+    )
+    (drop) (drop) (drop)
+  )
+)`);
+
+// ./test/core/if.wast:529
+assert_return(() => invoke($0, `empty`, [0]), []);
+
+// ./test/core/if.wast:530
+assert_return(() => invoke($0, `empty`, [1]), []);
+
+// ./test/core/if.wast:531
+assert_return(() => invoke($0, `empty`, [100]), []);
+
+// ./test/core/if.wast:532
+assert_return(() => invoke($0, `empty`, [-2]), []);
+
+// ./test/core/if.wast:534
+assert_return(() => invoke($0, `singular`, [0]), [value("i32", 8)]);
+
+// ./test/core/if.wast:535
+assert_return(() => invoke($0, `singular`, [1]), [value("i32", 7)]);
+
+// ./test/core/if.wast:536
+assert_return(() => invoke($0, `singular`, [10]), [value("i32", 7)]);
+
+// ./test/core/if.wast:537
+assert_return(() => invoke($0, `singular`, [-10]), [value("i32", 7)]);
+
+// ./test/core/if.wast:539
+assert_return(() => invoke($0, `multi`, [0]), [value("i32", 9), value("i32", -1)]);
+
+// ./test/core/if.wast:540
+assert_return(() => invoke($0, `multi`, [1]), [value("i32", 8), value("i32", 1)]);
+
+// ./test/core/if.wast:541
+assert_return(() => invoke($0, `multi`, [13]), [value("i32", 8), value("i32", 1)]);
+
+// ./test/core/if.wast:542
+assert_return(() => invoke($0, `multi`, [-5]), [value("i32", 8), value("i32", 1)]);
+
+// ./test/core/if.wast:544
+assert_return(() => invoke($0, `nested`, [0, 0]), [value("i32", 11)]);
+
+// ./test/core/if.wast:545
+assert_return(() => invoke($0, `nested`, [1, 0]), [value("i32", 10)]);
+
+// ./test/core/if.wast:546
+assert_return(() => invoke($0, `nested`, [0, 1]), [value("i32", 10)]);
+
+// ./test/core/if.wast:547
+assert_return(() => invoke($0, `nested`, [3, 2]), [value("i32", 9)]);
+
+// ./test/core/if.wast:548
+assert_return(() => invoke($0, `nested`, [0, -100]), [value("i32", 10)]);
+
+// ./test/core/if.wast:549
+assert_return(() => invoke($0, `nested`, [10, 10]), [value("i32", 9)]);
+
+// ./test/core/if.wast:550
+assert_return(() => invoke($0, `nested`, [0, -1]), [value("i32", 10)]);
+
+// ./test/core/if.wast:551
+assert_return(() => invoke($0, `nested`, [-111, -2]), [value("i32", 9)]);
+
+// ./test/core/if.wast:553
+assert_return(() => invoke($0, `as-select-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:554
+assert_return(() => invoke($0, `as-select-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:555
+assert_return(() => invoke($0, `as-select-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:556
+assert_return(() => invoke($0, `as-select-mid`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:557
+assert_return(() => invoke($0, `as-select-last`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:558
+assert_return(() => invoke($0, `as-select-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:560
+assert_return(() => invoke($0, `as-loop-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:561
+assert_return(() => invoke($0, `as-loop-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:562
+assert_return(() => invoke($0, `as-loop-mid`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:563
+assert_return(() => invoke($0, `as-loop-mid`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:564
+assert_return(() => invoke($0, `as-loop-last`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:565
+assert_return(() => invoke($0, `as-loop-last`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:567
+assert_return(() => invoke($0, `as-if-condition`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:568
+assert_return(() => invoke($0, `as-if-condition`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:570
+assert_return(() => invoke($0, `as-br_if-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:571
+assert_return(() => invoke($0, `as-br_if-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:572
+assert_return(() => invoke($0, `as-br_if-last`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:573
+assert_return(() => invoke($0, `as-br_if-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:575
+assert_return(() => invoke($0, `as-br_table-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:576
+assert_return(() => invoke($0, `as-br_table-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:577
+assert_return(() => invoke($0, `as-br_table-last`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:578
+assert_return(() => invoke($0, `as-br_table-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:580
+assert_return(() => invoke($0, `as-call_indirect-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:581
+assert_return(() => invoke($0, `as-call_indirect-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:582
+assert_return(() => invoke($0, `as-call_indirect-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:583
+assert_return(() => invoke($0, `as-call_indirect-mid`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:584
+assert_return(() => invoke($0, `as-call_indirect-last`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:585
+assert_trap(() => invoke($0, `as-call_indirect-last`, [1]), `undefined element`);
+
+// ./test/core/if.wast:587
+assert_return(() => invoke($0, `as-store-first`, [0]), []);
+
+// ./test/core/if.wast:588
+assert_return(() => invoke($0, `as-store-first`, [1]), []);
+
+// ./test/core/if.wast:589
+assert_return(() => invoke($0, `as-store-last`, [0]), []);
+
+// ./test/core/if.wast:590
+assert_return(() => invoke($0, `as-store-last`, [1]), []);
+
+// ./test/core/if.wast:592
+assert_return(() => invoke($0, `as-memory.grow-value`, [0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:593
+assert_return(() => invoke($0, `as-memory.grow-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:595
+assert_return(() => invoke($0, `as-call-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:596
+assert_return(() => invoke($0, `as-call-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:598
+assert_return(() => invoke($0, `as-return-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:599
+assert_return(() => invoke($0, `as-return-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:601
+assert_return(() => invoke($0, `as-drop-operand`, [0]), []);
+
+// ./test/core/if.wast:602
+assert_return(() => invoke($0, `as-drop-operand`, [1]), []);
+
+// ./test/core/if.wast:604
+assert_return(() => invoke($0, `as-br-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:605
+assert_return(() => invoke($0, `as-br-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:607
+assert_return(() => invoke($0, `as-local.set-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:608
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:610
+assert_return(() => invoke($0, `as-local.tee-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:611
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:613
+assert_return(() => invoke($0, `as-global.set-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:614
+assert_return(() => invoke($0, `as-global.set-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:616
+assert_return(() => invoke($0, `as-load-operand`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:617
+assert_return(() => invoke($0, `as-load-operand`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:619
+assert_return(() => invoke($0, `as-unary-operand`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:620
+assert_return(() => invoke($0, `as-unary-operand`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:621
+assert_return(() => invoke($0, `as-unary-operand`, [-1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:623
+assert_return(() => invoke($0, `as-binary-operand`, [0, 0]), [value("i32", 15)]);
+
+// ./test/core/if.wast:624
+assert_return(() => invoke($0, `as-binary-operand`, [0, 1]), [value("i32", -12)]);
+
+// ./test/core/if.wast:625
+assert_return(() => invoke($0, `as-binary-operand`, [1, 0]), [value("i32", -15)]);
+
+// ./test/core/if.wast:626
+assert_return(() => invoke($0, `as-binary-operand`, [1, 1]), [value("i32", 12)]);
+
+// ./test/core/if.wast:628
+assert_return(() => invoke($0, `as-test-operand`, [0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:629
+assert_return(() => invoke($0, `as-test-operand`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:631
+assert_return(() => invoke($0, `as-compare-operand`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:632
+assert_return(() => invoke($0, `as-compare-operand`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:633
+assert_return(() => invoke($0, `as-compare-operand`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:634
+assert_return(() => invoke($0, `as-compare-operand`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:636
+assert_return(() => invoke($0, `as-binary-operands`, [0]), [value("i32", -12)]);
+
+// ./test/core/if.wast:637
+assert_return(() => invoke($0, `as-binary-operands`, [1]), [value("i32", 12)]);
+
+// ./test/core/if.wast:639
+assert_return(() => invoke($0, `as-compare-operands`, [0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:640
+assert_return(() => invoke($0, `as-compare-operands`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:642
+assert_return(() => invoke($0, `as-mixed-operands`, [0]), [value("i32", -3)]);
+
+// ./test/core/if.wast:643
+assert_return(() => invoke($0, `as-mixed-operands`, [1]), [value("i32", 27)]);
+
+// ./test/core/if.wast:645
+assert_return(() => invoke($0, `break-bare`, []), [value("i32", 19)]);
+
+// ./test/core/if.wast:646
+assert_return(() => invoke($0, `break-value`, [1]), [value("i32", 18)]);
+
+// ./test/core/if.wast:647
+assert_return(() => invoke($0, `break-value`, [0]), [value("i32", 21)]);
+
+// ./test/core/if.wast:648
+assert_return(
+  () => invoke($0, `break-multi-value`, [0]),
+  [value("i32", -18), value("i32", 18), value("i64", -18n)],
+);
+
+// ./test/core/if.wast:651
+assert_return(
+  () => invoke($0, `break-multi-value`, [1]),
+  [value("i32", 18), value("i32", -18), value("i64", 18n)],
+);
+
+// ./test/core/if.wast:655
+assert_return(() => invoke($0, `param`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:656
+assert_return(() => invoke($0, `param`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:657
+assert_return(() => invoke($0, `params`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:658
+assert_return(() => invoke($0, `params`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:659
+assert_return(() => invoke($0, `params-id`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:660
+assert_return(() => invoke($0, `params-id`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:661
+assert_return(() => invoke($0, `param-break`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:662
+assert_return(() => invoke($0, `param-break`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:663
+assert_return(() => invoke($0, `params-break`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:664
+assert_return(() => invoke($0, `params-break`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:665
+assert_return(() => invoke($0, `params-id-break`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:666
+assert_return(() => invoke($0, `params-id-break`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:668
+assert_return(() => invoke($0, `effects`, [1]), [value("i32", -14)]);
+
+// ./test/core/if.wast:669
+assert_return(() => invoke($0, `effects`, [0]), [value("i32", -6)]);
+
+// ./test/core/if.wast:671
+assert_return(() => invoke($0, `add64_u_with_carry`, [0n, 0n, 0]), [value("i64", 0n), value("i32", 0)]);
+
+// ./test/core/if.wast:675
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [100n, 124n, 0]),
+  [value("i64", 224n), value("i32", 0)],
+);
+
+// ./test/core/if.wast:679
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [-1n, 0n, 0]),
+  [value("i64", -1n), value("i32", 0)],
+);
+
+// ./test/core/if.wast:683
+assert_return(() => invoke($0, `add64_u_with_carry`, [-1n, 1n, 0]), [value("i64", 0n), value("i32", 1)]);
+
+// ./test/core/if.wast:687
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [-1n, -1n, 0]),
+  [value("i64", -2n), value("i32", 1)],
+);
+
+// ./test/core/if.wast:691
+assert_return(() => invoke($0, `add64_u_with_carry`, [-1n, 0n, 1]), [value("i64", 0n), value("i32", 1)]);
+
+// ./test/core/if.wast:695
+assert_return(() => invoke($0, `add64_u_with_carry`, [-1n, 1n, 1]), [value("i64", 1n), value("i32", 1)]);
+
+// ./test/core/if.wast:699
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [
+    -9223372036854775808n,
+    -9223372036854775808n,
+    0,
+  ]),
+  [value("i64", 0n), value("i32", 1)],
+);
+
+// ./test/core/if.wast:704
+assert_return(() => invoke($0, `add64_u_saturated`, [0n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/if.wast:707
+assert_return(() => invoke($0, `add64_u_saturated`, [1230n, 23n]), [value("i64", 1253n)]);
+
+// ./test/core/if.wast:710
+assert_return(() => invoke($0, `add64_u_saturated`, [-1n, 0n]), [value("i64", -1n)]);
+
+// ./test/core/if.wast:713
+assert_return(() => invoke($0, `add64_u_saturated`, [-1n, 1n]), [value("i64", -1n)]);
+
+// ./test/core/if.wast:716
+assert_return(() => invoke($0, `add64_u_saturated`, [-1n, -1n]), [value("i64", -1n)]);
+
+// ./test/core/if.wast:719
+assert_return(
+  () => invoke($0, `add64_u_saturated`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/if.wast:723
+assert_return(() => invoke($0, `type-use`, []), []);
+
+// ./test/core/if.wast:725
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (type $$sig) (result i32) (param i32) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:734
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (param i32) (type $$sig) (result i32) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:743
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (param i32) (result i32) (type $$sig) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:752
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (result i32) (type $$sig) (param i32) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:761
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (result i32) (param i32) (type $$sig) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:770
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then))) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:777
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (i32.const 1)   (if (param $$x i32) (then (drop)) (else (drop))) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:785
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (func (i32.const 1)   (if (type $$sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))   (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:795
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 1)   (if (type $$sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))   (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:805
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (i32.const 1)   (if (type $$sig) (param i32) (then (drop)) (else (drop)))   (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:815
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (func (i32.const 0) (i32.const 1)   (if (type $$sig) (param i32) (result i32) (then)) (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:825
+assert_invalid(
+  () => instantiate(`(module
+    (type $$sig (func))
+    (func (i32.const 1) (if (type $$sig) (i32.const 0) (then)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:833
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:837
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:841
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:845
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:850
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:854
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:858
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:862
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:867
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:873
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-void-else
+    (if (i32.const 1) (then (i32.const 1)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:879
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-num-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:885
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:892
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:898
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-nums-vs-void-else
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:904
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-nums-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:910
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:917
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:923
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:929
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:936
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:942
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:948
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:955
+assert_invalid(
+  () => instantiate(`(module (func $$type-no-else-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:961
+assert_invalid(
+  () => instantiate(`(module (func $$type-no-else-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:968
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:974
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:980
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:987
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:993
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:999
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1006
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1012
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1018
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1025
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1031
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1037
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1044
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1051
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1058
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1066
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1072
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1078
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1085
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-different-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1091
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-different-value-nums-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1098
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 0)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (i64.const 0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1108
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (i64.const 0))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1118
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1129
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1135
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1141
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1147
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1154
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1163
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1172
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1181
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0) (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1191
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1200
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1209
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1218
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1228
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1237
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1246
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1255
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1264
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1274
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1285
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty
+      (if (then))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1293
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-block
+      (i32.const 0)
+      (block (if (then)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1302
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-loop
+      (i32.const 0)
+      (loop (if (then)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1311
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (if (then))))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1320
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0)))
+      (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1330
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-br
+      (i32.const 0)
+      (block (br 0 (if(then))) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1339
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (if(then)) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1348
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (if(then))) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1357
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-return
+      (return (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1365
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-select
+      (select (if(then)) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1373
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-call
+      (call 1 (if(then))) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1382
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-condition-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (if(then)) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1398
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-local.set
+      (local i32)
+      (local.set 0 (if(then))) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1407
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1416
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-condition-empty-in-global.set
+      (global.set $$x (if(then))) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1425
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-condition-empty-in-memory.grow
+      (memory.grow (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1434
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-condition-empty-in-load
+      (i32.load (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1443
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-condition-empty-in-store
+      (i32.store (if(then)) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1453
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-num
+    (if (param i32) (i32.const 1) (then (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1459
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (if (param i32 f64) (i32.const 1) (then (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1465
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1471
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1477
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-nested-void-vs-num
+    (block (if (param i32) (i32.const 1) (then (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1483
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (block (if (param i32 f64) (i32.const 1) (then (drop) (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1489
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1495
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1502
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) if (param $$x i32) end) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:1506
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) (if (param $$x i32) (then))) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:1511
+assert_malformed(() => instantiate(`(func i32.const 0 if end $$l) `), `mismatching label`);
+
+// ./test/core/if.wast:1515
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1519
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else $$l end) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1523
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else $$l end) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1527
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1531
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else $$l end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1535
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else $$l1 end $$l2) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1539
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1543
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else $$a end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1547
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else $$l end $$l) `),
+  `mismatching label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js
new file mode 100644
index 0000000000..41ba1bb574
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/local_get.wast.js
@@ -0,0 +1,316 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/local_get.wast
+
+// ./test/core/local_get.wast:3
+let $0 = instantiate(`(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "type-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "type-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "type-local-f64") (result f64) (local f64) (local.get 0))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.get 0))
+  (func (export "type-param-i64") (param i64) (result i64) (local.get 0))
+  (func (export "type-param-f32") (param f32) (result f32) (local.get 0))
+  (func (export "type-param-f64") (param f64) (result f64) (local.get 0))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32)
+    (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.get 0)))
+    (drop (f32.neg (local.get 1)))
+    (drop (f64.neg (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (i32.eqz (local.get 4)))
+    (drop (f32.neg (local.get 5)))
+    (drop (i64.eqz (local.get 6)))
+    (drop (i64.eqz (local.get 7)))
+    (drop (f64.neg (local.get 8)))
+  )
+
+  ;; Reading
+
+  (func (export "read") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (f64.add
+      (f64.convert_i64_u (local.get 0))
+      (f64.add
+        (f64.promote_f32 (local.get 1))
+        (f64.add
+          (local.get 2)
+          (f64.add
+            (f64.convert_i32_u (local.get 3))
+            (f64.add
+              (f64.convert_i32_s (local.get 4))
+              (f64.add
+                (f64.promote_f32 (local.get 5))
+                (f64.add
+                  (f64.convert_i64_u (local.get 6))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 7))
+                    (local.get 8)
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32) (result i32)
+    (block (result i32) (local.get 0))
+  )
+  (func (export "as-loop-value") (param i32) (result i32)
+    (loop (result i32) (local.get 0))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.get 0)))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block $$l0 (result i32) (br_if $$l0 (local.get 0) (i32.const 1)))
+  )
+
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0 (local.get 0) (local.get 0))
+    )
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (br_table 0 1 2 (local.get 0))
+          (return (i32.const 0))
+        )
+        (return (i32.const 1))
+      )
+      (return (i32.const 2))
+    )
+    (i32.const 3)
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.get 0))
+  )
+
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 0)) (else (i32.const 0)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (i32.const 1)) (else (local.get 0)))
+  )
+)`);
+
+// ./test/core/local_get.wast:109
+assert_return(() => invoke($0, `type-local-i32`, []), [value("i32", 0)]);
+
+// ./test/core/local_get.wast:110
+assert_return(() => invoke($0, `type-local-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/local_get.wast:111
+assert_return(() => invoke($0, `type-local-f32`, []), [value("f32", 0)]);
+
+// ./test/core/local_get.wast:112
+assert_return(() => invoke($0, `type-local-f64`, []), [value("f64", 0)]);
+
+// ./test/core/local_get.wast:114
+assert_return(() => invoke($0, `type-param-i32`, [2]), [value("i32", 2)]);
+
+// ./test/core/local_get.wast:115
+assert_return(() => invoke($0, `type-param-i64`, [3n]), [value("i64", 3n)]);
+
+// ./test/core/local_get.wast:116
+assert_return(() => invoke($0, `type-param-f32`, [value("f32", 4.4)]), [value("f32", 4.4)]);
+
+// ./test/core/local_get.wast:117
+assert_return(() => invoke($0, `type-param-f64`, [value("f64", 5.5)]), [value("f64", 5.5)]);
+
+// ./test/core/local_get.wast:119
+assert_return(() => invoke($0, `as-block-value`, [6]), [value("i32", 6)]);
+
+// ./test/core/local_get.wast:120
+assert_return(() => invoke($0, `as-loop-value`, [7]), [value("i32", 7)]);
+
+// ./test/core/local_get.wast:122
+assert_return(() => invoke($0, `as-br-value`, [8]), [value("i32", 8)]);
+
+// ./test/core/local_get.wast:123
+assert_return(() => invoke($0, `as-br_if-value`, [9]), [value("i32", 9)]);
+
+// ./test/core/local_get.wast:124
+assert_return(() => invoke($0, `as-br_if-value-cond`, [10]), [value("i32", 10)]);
+
+// ./test/core/local_get.wast:125
+assert_return(() => invoke($0, `as-br_table-value`, [1]), [value("i32", 2)]);
+
+// ./test/core/local_get.wast:127
+assert_return(() => invoke($0, `as-return-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_get.wast:129
+assert_return(() => invoke($0, `as-if-then`, [1]), [value("i32", 1)]);
+
+// ./test/core/local_get.wast:130
+assert_return(() => invoke($0, `as-if-else`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_get.wast:132
+assert_return(() => invoke($0, `type-mixed`, [1n, value("f32", 2.2), value("f64", 3.3), 4, 5]), []);
+
+// ./test/core/local_get.wast:138
+assert_return(
+  () => invoke($0, `read`, [1n, value("f32", 2), value("f64", 3.3), 4, 5]),
+  [value("f64", 34.8)],
+);
+
+// ./test/core/local_get.wast:148
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i64) (local i32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:152
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i32) (local f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:156
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result f64) (local f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:164
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param i32) (result i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:168
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f32) (result i32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:172
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f64 i64) (result f64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:180
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-i32 (local i32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:184
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-i64 (local i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:188
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-f32 (local f32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:192
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-f64 (local f64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:200
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-local (local i32 i64) (local.get 3) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:204
+assert_invalid(
+  () => instantiate(`(module (func $$large-local (local i32 i64) (local.get 14324343) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:209
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-param (param i32 i64) (local.get 2) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:213
+assert_invalid(
+  () => instantiate(`(module (func $$large-param (param i32 i64) (local.get 714324343) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:218
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-mixed (param i32) (local i32 i64) (local.get 3) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:222
+assert_invalid(
+  () => instantiate(`(module (func $$large-mixed (param i64) (local i32 i64) (local.get 214324343) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:230
+let $1 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/local_get.wast:252
+assert_invalid(
+  () => instantiate(`(module (func $$uninit (local $$x (ref extern)) (drop (local.get $$x))))`),
+  `uninitialized local`,
+);
+
+// ./test/core/local_get.wast:256
+assert_invalid(
+  () => instantiate(`(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/js/src/jit-test/tests/wasm/spec/function-references/ref.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/ref.wast.js
new file mode 100644
index 0000000000..5d2fce2314
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/ref.wast.js
@@ -0,0 +1,110 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/ref.wast
+
+// ./test/core/ref.wast:3
+let $0 = instantiate(`(module
+  (type $$t (func))
+
+  (func
+    (param
+      funcref
+      externref
+      (ref func)
+      (ref extern)
+      (ref 0)
+      (ref $$t)
+      (ref 0)
+      (ref $$t)
+      (ref null func)
+      (ref null extern)
+      (ref null 0)
+      (ref null $$t)
+    )
+  )
+)`);
+
+// ./test/core/ref.wast:27
+assert_invalid(
+  () => instantiate(`(module (type $$type-func-param-invalid (func (param (ref 1)))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:31
+assert_invalid(
+  () => instantiate(`(module (type $$type-func-result-invalid (func (result (ref 1)))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:36
+assert_invalid(
+  () => instantiate(`(module (global $$global-invalid (ref null 1) (ref.null 1)))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:41
+assert_invalid(
+  () => instantiate(`(module (table $$table-invalid 10 (ref null 1)))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:46
+assert_invalid(
+  () => instantiate(`(module (elem $$elem-invalid (ref 1)))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:51
+assert_invalid(
+  () => instantiate(`(module (func $$func-param-invalid (param (ref 1))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:55
+assert_invalid(
+  () => instantiate(`(module (func $$func-result-invalid (result (ref 1))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:59
+assert_invalid(
+  () => instantiate(`(module (func $$func-local-invalid (local (ref null 1))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:64
+assert_invalid(
+  () => instantiate(`(module (func $$block-result-invalid (drop (block (result (ref 1)) (unreachable)))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:68
+assert_invalid(
+  () => instantiate(`(module (func $$loop-result-invalid (drop (loop (result (ref 1)) (unreachable)))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:72
+assert_invalid(
+  () => instantiate(`(module (func $$if-invalid (drop (if (result (ref 1)) (then) (else)))))`),
+  `unknown type`,
+);
+
+// ./test/core/ref.wast:77
+assert_invalid(
+  () => instantiate(`(module (func $$select-result-invalid (drop (select (result (ref 1)) (unreachable)))))`),
+  `unknown type`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/ref_as_non_null.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/ref_as_non_null.wast.js
new file mode 100644
index 0000000000..af2628a7b6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/ref_as_non_null.wast.js
@@ -0,0 +1,71 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/ref_as_non_null.wast
+
+// ./test/core/ref_as_non_null.wast:1
+let $0 = instantiate(`(module
+  (type $$t (func (result i32)))
+
+  (func $$nn (param $$r (ref $$t)) (result i32)
+    (call_ref $$t (ref.as_non_null (local.get $$r)))
+  )
+  (func $$n (param $$r (ref null $$t)) (result i32)
+    (call_ref $$t (ref.as_non_null (local.get $$r)))
+  )
+
+  (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)
+    (unreachable)
+    (ref.as_non_null)
+    (call $$nn)
+  )
+)`);
+
+// ./test/core/ref_as_non_null.wast:25
+assert_trap(() => invoke($0, `unreachable`, []), `unreachable`);
+
+// ./test/core/ref_as_non_null.wast:27
+assert_trap(() => invoke($0, `nullable-null`, []), `null reference`);
+
+// ./test/core/ref_as_non_null.wast:28
+assert_return(() => invoke($0, `nonnullable-f`, []), [value("i32", 7)]);
+
+// ./test/core/ref_as_non_null.wast:29
+assert_return(() => invoke($0, `nullable-f`, []), [value("i32", 7)]);
+
+// ./test/core/ref_as_non_null.wast:31
+assert_invalid(
+  () => instantiate(`(module
+    (type $$t (func (result i32)))
+    (func $$g (param $$r (ref $$t)) (drop (ref.as_non_null (local.get $$r))))
+    (func (call $$g (ref.null $$t)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/ref_as_non_null.wast:41
+let $1 = instantiate(`(module
+  (type $$t (func))
+  (func (param $$r (ref $$t)) (drop (ref.as_non_null (local.get $$r))))
+  (func (param $$r (ref func)) (drop (ref.as_non_null (local.get $$r))))
+  (func (param $$r (ref extern)) (drop (ref.as_non_null (local.get $$r))))
+)`);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/ref_func.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/ref_func.wast.js
new file mode 100644
index 0000000000..3ca5cea002
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/ref_func.wast.js
@@ -0,0 +1,156 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/ref_func.wast
+
+// ./test/core/ref_func.wast:1
+let $0 = instantiate(`(module
+  (func (export "f") (param $$x i32) (result i32) (local.get $$x))
+)`);
+
+// ./test/core/ref_func.wast:4
+register($0, `M`);
+
+// ./test/core/ref_func.wast:6
+let $1 = instantiate(`(module
+  (func $$f (import "M" "f") (param i32) (result i32))
+  (func $$g (param $$x i32) (result i32)
+    (i32.add (local.get $$x) (i32.const 1))
+  )
+
+  (global funcref (ref.func $$f))
+  (global funcref (ref.func $$g))
+  (global $$v (mut funcref) (ref.func $$f))
+
+  (global funcref (ref.func $$gf1))
+  (global funcref (ref.func $$gf2))
+  (func (drop (ref.func $$ff1)) (drop (ref.func $$ff2)))
+  (elem declare func $$gf1 $$ff1)
+  (elem declare funcref (ref.func $$gf2) (ref.func $$ff2))
+  (func $$gf1)
+  (func $$gf2)
+  (func $$ff1)
+  (func $$ff2)
+
+  (func (export "is_null-f") (result i32)
+    (ref.is_null (ref.func $$f))
+  )
+  (func (export "is_null-g") (result i32)
+    (ref.is_null (ref.func $$g))
+  )
+  (func (export "is_null-v") (result i32)
+    (ref.is_null (global.get $$v))
+  )
+
+  (func (export "set-f") (global.set $$v (ref.func $$f)))
+  (func (export "set-g") (global.set $$v (ref.func $$g)))
+
+  (table $$t 1 funcref)
+  (elem declare func $$f $$g)
+
+  (func (export "call-f") (param $$x i32) (result i32)
+    (table.set $$t (i32.const 0) (ref.func $$f))
+    (call_indirect $$t (param i32) (result i32) (local.get $$x) (i32.const 0))
+  )
+  (func (export "call-g") (param $$x i32) (result i32)
+    (table.set $$t (i32.const 0) (ref.func $$g))
+    (call_indirect $$t (param i32) (result i32) (local.get $$x) (i32.const 0))
+  )
+  (func (export "call-v") (param $$x i32) (result i32)
+    (table.set $$t (i32.const 0) (global.get $$v))
+    (call_indirect $$t (param i32) (result i32) (local.get $$x) (i32.const 0))
+  )
+)`);
+
+// ./test/core/ref_func.wast:56
+assert_return(() => invoke($1, `is_null-f`, []), [value("i32", 0)]);
+
+// ./test/core/ref_func.wast:57
+assert_return(() => invoke($1, `is_null-g`, []), [value("i32", 0)]);
+
+// ./test/core/ref_func.wast:58
+assert_return(() => invoke($1, `is_null-v`, []), [value("i32", 0)]);
+
+// ./test/core/ref_func.wast:60
+assert_return(() => invoke($1, `call-f`, [4]), [value("i32", 4)]);
+
+// ./test/core/ref_func.wast:61
+assert_return(() => invoke($1, `call-g`, [4]), [value("i32", 5)]);
+
+// ./test/core/ref_func.wast:62
+assert_return(() => invoke($1, `call-v`, [4]), [value("i32", 4)]);
+
+// ./test/core/ref_func.wast:63
+invoke($1, `set-g`, []);
+
+// ./test/core/ref_func.wast:64
+assert_return(() => invoke($1, `call-v`, [4]), [value("i32", 5)]);
+
+// ./test/core/ref_func.wast:65
+invoke($1, `set-f`, []);
+
+// ./test/core/ref_func.wast:66
+assert_return(() => invoke($1, `call-v`, [4]), [value("i32", 4)]);
+
+// ./test/core/ref_func.wast:68
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (import "M" "f") (param i32) (result i32))
+    (func $$g (import "M" "g") (param i32) (result i32))
+    (global funcref (ref.func 7))
+  )`),
+  `unknown function 7`,
+);
+
+// ./test/core/ref_func.wast:80
+let $2 = instantiate(`(module
+  (func $$f1)
+  (func $$f2)
+  (func $$f3)
+  (func $$f4)
+  (func $$f5)
+  (func $$f6)
+
+  (table $$t 1 funcref)
+
+  (global funcref (ref.func $$f1))
+  (export "f" (func $$f2))
+  (elem (table $$t) (i32.const 0) func $$f3)
+  (elem (table $$t) (i32.const 0) funcref (ref.func $$f4))
+  (elem func $$f5)
+  (elem funcref (ref.func $$f6))
+
+  (func
+    (ref.func $$f1)
+    (ref.func $$f2)
+    (ref.func $$f3)
+    (ref.func $$f4)
+    (ref.func $$f5)
+    (ref.func $$f6)
+    (return)
+  )
+)`);
+
+// ./test/core/ref_func.wast:108
+assert_invalid(
+  () => instantiate(`(module (func $$f (drop (ref.func $$f))))`),
+  `undeclared function reference`,
+);
+
+// ./test/core/ref_func.wast:112
+assert_invalid(
+  () => instantiate(`(module (start $$f) (func $$f (drop (ref.func $$f))))`),
+  `undeclared function reference`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/table_fill.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/table_fill.wast.js
new file mode 100644
index 0000000000..9381e67fc5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/table_fill.wast.js
@@ -0,0 +1,234 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_fill.wast
+
+// ./test/core/table_fill.wast:1
+let $0 = instantiate(`(module
+  (table $$t 10 externref)
+
+  (func (export "fill") (param $$i i32) (param $$r externref) (param $$n i32)
+    (table.fill $$t (local.get $$i) (local.get $$r) (local.get $$n))
+  )
+
+  (func (export "get") (param $$i i32) (result externref)
+    (table.get $$t (local.get $$i))
+  )
+)`);
+
+// ./test/core/table_fill.wast:13
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:14
+assert_return(() => invoke($0, `get`, [2]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:15
+assert_return(() => invoke($0, `get`, [3]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:16
+assert_return(() => invoke($0, `get`, [4]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:17
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:19
+assert_return(() => invoke($0, `fill`, [2, externref(1), 3]), []);
+
+// ./test/core/table_fill.wast:20
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:21
+assert_return(() => invoke($0, `get`, [2]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:22
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:23
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:24
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:26
+assert_return(() => invoke($0, `fill`, [4, externref(2), 2]), []);
+
+// ./test/core/table_fill.wast:27
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:28
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:29
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:30
+assert_return(() => invoke($0, `get`, [6]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:32
+assert_return(() => invoke($0, `fill`, [4, externref(3), 0]), []);
+
+// ./test/core/table_fill.wast:33
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:34
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:35
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:37
+assert_return(() => invoke($0, `fill`, [8, externref(4), 2]), []);
+
+// ./test/core/table_fill.wast:38
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:39
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:40
+assert_return(() => invoke($0, `get`, [9]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:42
+assert_return(() => invoke($0, `fill`, [9, null, 1]), []);
+
+// ./test/core/table_fill.wast:43
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:44
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:46
+assert_return(() => invoke($0, `fill`, [10, externref(5), 0]), []);
+
+// ./test/core/table_fill.wast:47
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:49
+assert_trap(() => invoke($0, `fill`, [8, externref(6), 3]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:53
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:54
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:55
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:57
+assert_trap(() => invoke($0, `fill`, [11, null, 0]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:62
+assert_trap(() => invoke($0, `fill`, [11, null, 10]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:70
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-value-length-empty-vs-i32-i32
+      (table.fill $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:79
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32
+      (table.fill $$t (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:88
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-value-empty-vs
+      (table.fill $$t (i32.const 1) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:97
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-length-empty-vs-i32
+      (table.fill $$t (i32.const 1) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:106
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-index-f32-vs-i32
+      (table.fill $$t (f32.const 1) (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:115
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 funcref)
+    (func $$type-value-vs-funcref (param $$r externref)
+      (table.fill $$t (i32.const 1) (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:124
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-length-f32-vs-i32
+      (table.fill $$t (i32.const 1) (ref.null extern) (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:134
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 externref)
+    (table $$t2 1 funcref)
+    (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+      (table.fill $$t2 (i32.const 0) (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:145
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-empty-vs-num (result i32)
+      (table.fill $$t (i32.const 0) (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/table_get.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/table_get.wast.js
new file mode 100644
index 0000000000..f4982cde3a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/table_get.wast.js
@@ -0,0 +1,126 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_get.wast
+
+// ./test/core/table_get.wast:1
+let $0 = instantiate(`(module
+  (table $$t2 2 externref)
+  (table $$t3 3 funcref)
+  (elem (table $$t3) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "init") (param $$r externref)
+    (table.set $$t2 (i32.const 1) (local.get $$r))
+    (table.set $$t3 (i32.const 2) (table.get $$t3 (i32.const 1)))
+  )
+
+  (func (export "get-externref") (param $$i i32) (result externref)
+    (table.get $$t2 (local.get $$i))
+  )
+  (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+    (table.get $$t3 (local.get $$i))
+  )
+
+  (func (export "is_null-funcref") (param $$i i32) (result i32)
+    (ref.is_null (call $$f3 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/table_get.wast:24
+invoke($0, `init`, [externref(1)]);
+
+// ./test/core/table_get.wast:26
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_get.wast:27
+assert_return(() => invoke($0, `get-externref`, [1]), [value('externref', externref(1))]);
+
+// ./test/core/table_get.wast:29
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_get.wast:30
+assert_return(() => invoke($0, `is_null-funcref`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:31
+assert_return(() => invoke($0, `is_null-funcref`, [2]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:33
+assert_trap(() => invoke($0, `get-externref`, [2]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:34
+assert_trap(() => invoke($0, `get-funcref`, [3]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:35
+assert_trap(() => invoke($0, `get-externref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:36
+assert_trap(() => invoke($0, `get-funcref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:41
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32 (result externref)
+      (table.get $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:50
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-f32-vs-i32 (result externref)
+      (table.get $$t (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:60
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-externref-vs-empty
+      (table.get $$t (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:69
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-externref-vs-funcref (result funcref)
+      (table.get $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:79
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 funcref)
+    (table $$t2 1 externref)
+    (func $$type-result-externref-vs-funcref-multi (result funcref)
+      (table.get $$t2 (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/table_grow.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/table_grow.wast.js
new file mode 100644
index 0000000000..f299984d66
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/table_grow.wast.js
@@ -0,0 +1,268 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_grow.wast
+
+// ./test/core/table_grow.wast:1
+let $0 = instantiate(`(module
+  (table $$t 0 externref)
+
+  (func (export "get") (param $$i i32) (result externref) (table.get $$t (local.get $$i)))
+  (func (export "set") (param $$i i32) (param $$r externref) (table.set $$t (local.get $$i) (local.get $$r)))
+
+  (func (export "grow") (param $$sz i32) (param $$init externref) (result i32)
+    (table.grow $$t (local.get $$init) (local.get $$sz))
+  )
+  (func (export "size") (result i32) (table.size $$t))
+)`);
+
+// ./test/core/table_grow.wast:13
+assert_return(() => invoke($0, `size`, []), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:14
+assert_trap(() => invoke($0, `set`, [0, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:15
+assert_trap(() => invoke($0, `get`, [0]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:17
+assert_return(() => invoke($0, `grow`, [1, null]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:18
+assert_return(() => invoke($0, `size`, []), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:19
+assert_return(() => invoke($0, `get`, [0]), [value('externref', null)]);
+
+// ./test/core/table_grow.wast:20
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:21
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:22
+assert_trap(() => invoke($0, `set`, [1, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:23
+assert_trap(() => invoke($0, `get`, [1]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:25
+assert_return(() => invoke($0, `grow`, [4, externref(3)]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:26
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/table_grow.wast:27
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:28
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:29
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:30
+assert_return(() => invoke($0, `get`, [1]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:31
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:32
+assert_return(() => invoke($0, `set`, [4, externref(4)]), []);
+
+// ./test/core/table_grow.wast:33
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(4))]);
+
+// ./test/core/table_grow.wast:34
+assert_trap(() => invoke($0, `set`, [5, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:35
+assert_trap(() => invoke($0, `get`, [5]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:39
+let $1 = instantiate(`(module
+  (table $$t 0x10 funcref)
+  (elem declare func $$f)
+  (func $$f (export "grow") (result i32)
+    (table.grow $$t (ref.func $$f) (i32.const 0xffff_fff0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:47
+assert_return(() => invoke($1, `grow`, []), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:50
+let $2 = instantiate(`(module
+  (table $$t 0 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null extern) (local.get 0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:57
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:58
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:59
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:60
+assert_return(() => invoke($2, `grow`, [2]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:61
+assert_return(() => invoke($2, `grow`, [800]), [value("i32", 3)]);
+
+// ./test/core/table_grow.wast:64
+let $3 = instantiate(`(module
+  (table $$t 0 10 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null extern) (local.get 0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:71
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:72
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:73
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:74
+assert_return(() => invoke($3, `grow`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_grow.wast:75
+assert_return(() => invoke($3, `grow`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_grow.wast:76
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:77
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:78
+assert_return(() => invoke($3, `grow`, [65536]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:81
+let $4 = instantiate(`(module
+  (table $$t 10 funcref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null func) (local.get 0))
+  )
+  (elem declare func 1)
+  (func (export "check-table-null") (param i32 i32) (result funcref)
+    (local funcref)
+    (local.set 2 (ref.func 1))
+    (block
+      (loop
+        (local.set 2 (table.get $$t (local.get 0)))
+        (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)`);
+
+// ./test/core/table_grow.wast:103
+assert_return(() => invoke($4, `check-table-null`, [0, 9]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:104
+assert_return(() => invoke($4, `grow`, [10]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:105
+assert_return(() => invoke($4, `check-table-null`, [0, 19]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:110
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-init-size-empty-vs-i32-externref (result i32)
+      (table.grow $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:119
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-size-empty-vs-i32 (result i32)
+      (table.grow $$t (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:128
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-init-empty-vs-externref (result i32)
+      (table.grow $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:137
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-size-f32-vs-i32 (result i32)
+      (table.grow $$t (ref.null extern) (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:146
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 funcref)
+    (func $$type-init-externref-vs-funcref (param $$r externref) (result i32)
+      (table.grow $$t (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:156
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-empty
+      (table.grow $$t (ref.null extern) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:165
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (table.grow $$t (ref.null extern) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/table_set.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/table_set.wast.js
new file mode 100644
index 0000000000..b44fcfc002
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/table_set.wast.js
@@ -0,0 +1,177 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_set.wast
+
+// ./test/core/table_set.wast:1
+let $0 = instantiate(`(module
+  (table $$t2 1 externref)
+  (table $$t3 2 funcref)
+  (elem (table $$t3) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "get-externref") (param $$i i32) (result externref)
+    (table.get $$t2 (local.get $$i))
+  )
+  (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+    (table.get $$t3 (local.get $$i))
+  )
+
+  (func (export "set-externref") (param $$i i32) (param $$r externref)
+    (table.set $$t2 (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))
+  )
+  (func (export "set-funcref-from") (param $$i i32) (param $$j i32)
+    (table.set $$t3 (local.get $$i) (table.get $$t3 (local.get $$j)))
+  )
+
+  (func (export "is_null-funcref") (param $$i i32) (result i32)
+    (ref.is_null (call $$f3 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/table_set.wast:29
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:30
+assert_return(() => invoke($0, `set-externref`, [0, externref(1)]), []);
+
+// ./test/core/table_set.wast:31
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', externref(1))]);
+
+// ./test/core/table_set.wast:32
+assert_return(() => invoke($0, `set-externref`, [0, null]), []);
+
+// ./test/core/table_set.wast:33
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:35
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:36
+assert_return(() => invoke($0, `set-funcref-from`, [0, 1]), []);
+
+// ./test/core/table_set.wast:37
+assert_return(() => invoke($0, `is_null-funcref`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_set.wast:38
+assert_return(() => invoke($0, `set-funcref`, [0, null]), []);
+
+// ./test/core/table_set.wast:39
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:41
+assert_trap(() => invoke($0, `set-externref`, [2, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:42
+assert_trap(() => invoke($0, `set-funcref`, [3, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:43
+assert_trap(() => invoke($0, `set-externref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:44
+assert_trap(() => invoke($0, `set-funcref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:46
+assert_trap(() => invoke($0, `set-externref`, [2, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:47
+assert_trap(() => invoke($0, `set-funcref-from`, [3, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:48
+assert_trap(() => invoke($0, `set-externref`, [-1, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:49
+assert_trap(() => invoke($0, `set-funcref-from`, [-1, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:54
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-value-empty-vs-i32-externref
+      (table.set $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:63
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32
+      (table.set $$t (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:72
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-value-empty-vs-externref
+      (table.set $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:81
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-size-f32-vs-i32
+      (table.set $$t (f32.const 1) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:90
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 funcref)
+    (func $$type-value-externref-vs-funcref (param $$r externref)
+      (table.set $$t (i32.const 1) (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:100
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 externref)
+    (table $$t2 1 funcref)
+    (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+      (table.set $$t2 (i32.const 0) (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:111
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-empty-vs-num (result i32)
+      (table.set $$t (i32.const 0) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/table_size.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/table_size.wast.js
new file mode 100644
index 0000000000..1a574c2ba9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/table_size.wast.js
@@ -0,0 +1,172 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_size.wast
+
+// ./test/core/table_size.wast:1
+let $0 = instantiate(`(module
+  (table $$t0 0 externref)
+  (table $$t1 1 externref)
+  (table $$t2 0 2 externref)
+  (table $$t3 3 8 externref)
+
+  (func (export "size-t0") (result i32) (table.size $$t0))
+  (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))
+
+  (func (export "grow-t0") (param $$sz i32)
+    (drop (table.grow $$t0 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t1") (param $$sz i32)
+    (drop (table.grow $$t1 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t2") (param $$sz i32)
+    (drop (table.grow $$t2 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t3") (param $$sz i32)
+    (drop (table.grow $$t3 (ref.null extern) (local.get $$sz)))
+  )
+)`);
+
+// ./test/core/table_size.wast:26
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:27
+assert_return(() => invoke($0, `grow-t0`, [1]), []);
+
+// ./test/core/table_size.wast:28
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:29
+assert_return(() => invoke($0, `grow-t0`, [4]), []);
+
+// ./test/core/table_size.wast:30
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:31
+assert_return(() => invoke($0, `grow-t0`, [0]), []);
+
+// ./test/core/table_size.wast:32
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:34
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:35
+assert_return(() => invoke($0, `grow-t1`, [1]), []);
+
+// ./test/core/table_size.wast:36
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:37
+assert_return(() => invoke($0, `grow-t1`, [4]), []);
+
+// ./test/core/table_size.wast:38
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:39
+assert_return(() => invoke($0, `grow-t1`, [0]), []);
+
+// ./test/core/table_size.wast:40
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:42
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:43
+assert_return(() => invoke($0, `grow-t2`, [3]), []);
+
+// ./test/core/table_size.wast:44
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:45
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:46
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:47
+assert_return(() => invoke($0, `grow-t2`, [0]), []);
+
+// ./test/core/table_size.wast:48
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:49
+assert_return(() => invoke($0, `grow-t2`, [4]), []);
+
+// ./test/core/table_size.wast:50
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:51
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:52
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:54
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 3)]);
+
+// ./test/core/table_size.wast:55
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:56
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 4)]);
+
+// ./test/core/table_size.wast:57
+assert_return(() => invoke($0, `grow-t3`, [3]), []);
+
+// ./test/core/table_size.wast:58
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:59
+assert_return(() => invoke($0, `grow-t3`, [0]), []);
+
+// ./test/core/table_size.wast:60
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:61
+assert_return(() => invoke($0, `grow-t3`, [2]), []);
+
+// ./test/core/table_size.wast:62
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:63
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:64
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 8)]);
+
+// ./test/core/table_size.wast:69
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-empty
+      (table.size $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_size.wast:78
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (table.size $$t)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/function-references/unreached-valid.wast.js b/js/src/jit-test/tests/wasm/spec/function-references/unreached-valid.wast.js
new file mode 100644
index 0000000000..e25a157431
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/function-references/unreached-valid.wast.js
@@ -0,0 +1,109 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/unreached-valid.wast
+
+// ./test/core/unreached-valid.wast:1
+let $0 = instantiate(`(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-result1") (result i32)
+    (unreachable) (i32.add (select))
+  )
+
+  (func (export "select-unreached-result2") (result i64)
+    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+  )
+
+  (func (export "select-unreached-num")
+    (unreachable)
+    (select)
+    (i32.eqz)
+    (drop)
+  )
+  (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)
+  )
+)`);
+
+// ./test/core/unreached-valid.wast:48
+assert_trap(() => invoke($0, `select-trap-left`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:49
+assert_trap(() => invoke($0, `select-trap-left`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:50
+assert_trap(() => invoke($0, `select-trap-right`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:51
+assert_trap(() => invoke($0, `select-trap-right`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:53
+assert_trap(() => invoke($0, `select-unreached-result1`, []), `unreachable`);
+
+// ./test/core/unreached-valid.wast:54
+assert_trap(() => invoke($0, `select-unreached-result2`, []), `unreachable`);
+
+// ./test/core/unreached-valid.wast:55
+assert_trap(() => invoke($0, `select-unreached-num`, []), `unreachable`);
+
+// ./test/core/unreached-valid.wast:56
+assert_trap(() => invoke($0, `select-unreached-ref`, []), `unreachable`);
+
+// ./test/core/unreached-valid.wast:58
+assert_trap(() => invoke($0, `call_ref-unreached`, []), `unreachable`);
+
+// ./test/core/unreached-valid.wast:63
+let $1 = instantiate(`(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)
+  )
+)`);
+
+// ./test/core/unreached-valid.wast:77
+assert_trap(() => invoke($1, `meet-bottom`, []), `unreachable`);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/address64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/address64.wast.js
new file mode 100644
index 0000000000..c6de7e8ed7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/address64.wast.js
@@ -0,0 +1,1025 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/address64.wast
+
+// ./test/core/address64.wast:3
+let $0 = instantiate(`(module
+  (memory i64 1)
+  (data (i64.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $$i i64) (result i32)
+    (i32.load8_u offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $$i i64) (result i32)
+    (i32.load8_u align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $$i i64) (result i32)
+    (i32.load8_u offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $$i i64) (result i32)
+    (i32.load8_u offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $$i i64) (result i32)
+    (i32.load8_u offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $$i i64) (result i32)
+    (i32.load8_s offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $$i i64) (result i32)
+    (i32.load8_s align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $$i i64) (result i32)
+    (i32.load8_s offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $$i i64) (result i32)
+    (i32.load8_s offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $$i i64) (result i32)
+    (i32.load8_s offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $$i i64) (result i32)
+    (i32.load16_u offset=0 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $$i i64) (result i32)
+    (i32.load16_u align=1 (local.get $$i))                   ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $$i i64) (result i32)
+    (i32.load16_u offset=1 align=1 (local.get $$i))          ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $$i i64) (result i32)
+    (i32.load16_u offset=2 align=2 (local.get $$i))          ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $$i i64) (result i32)
+    (i32.load16_u offset=25 align=2 (local.get $$i))         ;; 122 'z\\0'
+  )
+
+  (func (export "16s_good1") (param $$i i64) (result i32)
+    (i32.load16_s offset=0 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $$i i64) (result i32)
+    (i32.load16_s align=1 (local.get $$i))                   ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $$i i64) (result i32)
+    (i32.load16_s offset=1 align=1 (local.get $$i))          ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $$i i64) (result i32)
+    (i32.load16_s offset=2 align=2 (local.get $$i))          ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $$i i64) (result i32)
+    (i32.load16_s offset=25 align=2 (local.get $$i))         ;; 122 'z\\0'
+  )
+
+  (func (export "32_good1") (param $$i i64) (result i32)
+    (i32.load offset=0 (local.get $$i))                      ;; 1684234849 'abcd'
+  )
+  (func (export "32_good2") (param $$i i64) (result i32)
+    (i32.load align=1 (local.get $$i))                       ;; 1684234849 'abcd'
+  )
+  (func (export "32_good3") (param $$i i64) (result i32)
+    (i32.load offset=1 align=1 (local.get $$i))              ;; 1701077858 'bcde'
+  )
+  (func (export "32_good4") (param $$i i64) (result i32)
+    (i32.load offset=2 align=2 (local.get $$i))              ;; 1717920867 'cdef'
+  )
+  (func (export "32_good5") (param $$i i64) (result i32)
+    (i32.load offset=25 align=4 (local.get $$i))             ;; 122 'z\\0\\0\\0'
+  )
+
+  (func (export "8u_bad") (param $$i i64)
+    (drop (i32.load8_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "8s_bad") (param $$i i64)
+    (drop (i32.load8_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16u_bad") (param $$i i64)
+    (drop (i32.load16_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16s_bad") (param $$i i64)
+    (drop (i32.load16_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "32_bad") (param $$i i64)
+    (drop (i32.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address64.wast:104
+assert_return(() => invoke($0, `8u_good1`, [0n]), [value("i32", 97)]);
+
+// ./test/core/address64.wast:105
+assert_return(() => invoke($0, `8u_good2`, [0n]), [value("i32", 97)]);
+
+// ./test/core/address64.wast:106
+assert_return(() => invoke($0, `8u_good3`, [0n]), [value("i32", 98)]);
+
+// ./test/core/address64.wast:107
+assert_return(() => invoke($0, `8u_good4`, [0n]), [value("i32", 99)]);
+
+// ./test/core/address64.wast:108
+assert_return(() => invoke($0, `8u_good5`, [0n]), [value("i32", 122)]);
+
+// ./test/core/address64.wast:110
+assert_return(() => invoke($0, `8s_good1`, [0n]), [value("i32", 97)]);
+
+// ./test/core/address64.wast:111
+assert_return(() => invoke($0, `8s_good2`, [0n]), [value("i32", 97)]);
+
+// ./test/core/address64.wast:112
+assert_return(() => invoke($0, `8s_good3`, [0n]), [value("i32", 98)]);
+
+// ./test/core/address64.wast:113
+assert_return(() => invoke($0, `8s_good4`, [0n]), [value("i32", 99)]);
+
+// ./test/core/address64.wast:114
+assert_return(() => invoke($0, `8s_good5`, [0n]), [value("i32", 122)]);
+
+// ./test/core/address64.wast:116
+assert_return(() => invoke($0, `16u_good1`, [0n]), [value("i32", 25185)]);
+
+// ./test/core/address64.wast:117
+assert_return(() => invoke($0, `16u_good2`, [0n]), [value("i32", 25185)]);
+
+// ./test/core/address64.wast:118
+assert_return(() => invoke($0, `16u_good3`, [0n]), [value("i32", 25442)]);
+
+// ./test/core/address64.wast:119
+assert_return(() => invoke($0, `16u_good4`, [0n]), [value("i32", 25699)]);
+
+// ./test/core/address64.wast:120
+assert_return(() => invoke($0, `16u_good5`, [0n]), [value("i32", 122)]);
+
+// ./test/core/address64.wast:122
+assert_return(() => invoke($0, `16s_good1`, [0n]), [value("i32", 25185)]);
+
+// ./test/core/address64.wast:123
+assert_return(() => invoke($0, `16s_good2`, [0n]), [value("i32", 25185)]);
+
+// ./test/core/address64.wast:124
+assert_return(() => invoke($0, `16s_good3`, [0n]), [value("i32", 25442)]);
+
+// ./test/core/address64.wast:125
+assert_return(() => invoke($0, `16s_good4`, [0n]), [value("i32", 25699)]);
+
+// ./test/core/address64.wast:126
+assert_return(() => invoke($0, `16s_good5`, [0n]), [value("i32", 122)]);
+
+// ./test/core/address64.wast:128
+assert_return(() => invoke($0, `32_good1`, [0n]), [value("i32", 1684234849)]);
+
+// ./test/core/address64.wast:129
+assert_return(() => invoke($0, `32_good2`, [0n]), [value("i32", 1684234849)]);
+
+// ./test/core/address64.wast:130
+assert_return(() => invoke($0, `32_good3`, [0n]), [value("i32", 1701077858)]);
+
+// ./test/core/address64.wast:131
+assert_return(() => invoke($0, `32_good4`, [0n]), [value("i32", 1717920867)]);
+
+// ./test/core/address64.wast:132
+assert_return(() => invoke($0, `32_good5`, [0n]), [value("i32", 122)]);
+
+// ./test/core/address64.wast:134
+assert_return(() => invoke($0, `8u_good1`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:135
+assert_return(() => invoke($0, `8u_good2`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:136
+assert_return(() => invoke($0, `8u_good3`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:137
+assert_return(() => invoke($0, `8u_good4`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:138
+assert_return(() => invoke($0, `8u_good5`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:140
+assert_return(() => invoke($0, `8s_good1`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:141
+assert_return(() => invoke($0, `8s_good2`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:142
+assert_return(() => invoke($0, `8s_good3`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:143
+assert_return(() => invoke($0, `8s_good4`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:144
+assert_return(() => invoke($0, `8s_good5`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:146
+assert_return(() => invoke($0, `16u_good1`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:147
+assert_return(() => invoke($0, `16u_good2`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:148
+assert_return(() => invoke($0, `16u_good3`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:149
+assert_return(() => invoke($0, `16u_good4`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:150
+assert_return(() => invoke($0, `16u_good5`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:152
+assert_return(() => invoke($0, `16s_good1`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:153
+assert_return(() => invoke($0, `16s_good2`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:154
+assert_return(() => invoke($0, `16s_good3`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:155
+assert_return(() => invoke($0, `16s_good4`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:156
+assert_return(() => invoke($0, `16s_good5`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:158
+assert_return(() => invoke($0, `32_good1`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:159
+assert_return(() => invoke($0, `32_good2`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:160
+assert_return(() => invoke($0, `32_good3`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:161
+assert_return(() => invoke($0, `32_good4`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:162
+assert_return(() => invoke($0, `32_good5`, [65507n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:164
+assert_return(() => invoke($0, `8u_good1`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:165
+assert_return(() => invoke($0, `8u_good2`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:166
+assert_return(() => invoke($0, `8u_good3`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:167
+assert_return(() => invoke($0, `8u_good4`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:168
+assert_return(() => invoke($0, `8u_good5`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:170
+assert_return(() => invoke($0, `8s_good1`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:171
+assert_return(() => invoke($0, `8s_good2`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:172
+assert_return(() => invoke($0, `8s_good3`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:173
+assert_return(() => invoke($0, `8s_good4`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:174
+assert_return(() => invoke($0, `8s_good5`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:176
+assert_return(() => invoke($0, `16u_good1`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:177
+assert_return(() => invoke($0, `16u_good2`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:178
+assert_return(() => invoke($0, `16u_good3`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:179
+assert_return(() => invoke($0, `16u_good4`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:180
+assert_return(() => invoke($0, `16u_good5`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:182
+assert_return(() => invoke($0, `16s_good1`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:183
+assert_return(() => invoke($0, `16s_good2`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:184
+assert_return(() => invoke($0, `16s_good3`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:185
+assert_return(() => invoke($0, `16s_good4`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:186
+assert_return(() => invoke($0, `16s_good5`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:188
+assert_return(() => invoke($0, `32_good1`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:189
+assert_return(() => invoke($0, `32_good2`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:190
+assert_return(() => invoke($0, `32_good3`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:191
+assert_return(() => invoke($0, `32_good4`, [65508n]), [value("i32", 0)]);
+
+// ./test/core/address64.wast:192
+assert_trap(() => invoke($0, `32_good5`, [65508n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:194
+assert_trap(() => invoke($0, `8u_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:195
+assert_trap(() => invoke($0, `8s_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:196
+assert_trap(() => invoke($0, `16u_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:197
+assert_trap(() => invoke($0, `16s_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:198
+assert_trap(() => invoke($0, `32_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:200
+assert_trap(() => invoke($0, `8u_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:201
+assert_trap(() => invoke($0, `8s_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:202
+assert_trap(() => invoke($0, `16u_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:203
+assert_trap(() => invoke($0, `16s_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:204
+assert_trap(() => invoke($0, `32_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:209
+let $1 = instantiate(`(module
+  (memory i64 1)
+  (data (i64.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $$i i64) (result i64)
+    (i64.load8_u offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $$i i64) (result i64)
+    (i64.load8_u align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $$i i64) (result i64)
+    (i64.load8_u offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $$i i64) (result i64)
+    (i64.load8_u offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $$i i64) (result i64)
+    (i64.load8_u offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $$i i64) (result i64)
+    (i64.load8_s offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $$i i64) (result i64)
+    (i64.load8_s align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $$i i64) (result i64)
+    (i64.load8_s offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $$i i64) (result i64)
+    (i64.load8_s offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $$i i64) (result i64)
+    (i64.load8_s offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $$i i64) (result i64)
+    (i64.load16_u offset=0 (local.get $$i))                 ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $$i i64) (result i64)
+    (i64.load16_u align=1 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $$i i64) (result i64)
+    (i64.load16_u offset=1 align=1 (local.get $$i))         ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $$i i64) (result i64)
+    (i64.load16_u offset=2 align=2 (local.get $$i))         ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $$i i64) (result i64)
+    (i64.load16_u offset=25 align=2 (local.get $$i))        ;; 122 'z\\0'
+  )
+
+  (func (export "16s_good1") (param $$i i64) (result i64)
+    (i64.load16_s offset=0 (local.get $$i))                 ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $$i i64) (result i64)
+    (i64.load16_s align=1 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $$i i64) (result i64)
+    (i64.load16_s offset=1 align=1 (local.get $$i))         ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $$i i64) (result i64)
+    (i64.load16_s offset=2 align=2 (local.get $$i))         ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $$i i64) (result i64)
+    (i64.load16_s offset=25 align=2 (local.get $$i))        ;; 122 'z\\0'
+  )
+
+  (func (export "32u_good1") (param $$i i64) (result i64)
+    (i64.load32_u offset=0 (local.get $$i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good2") (param $$i i64) (result i64)
+    (i64.load32_u align=1 (local.get $$i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good3") (param $$i i64) (result i64)
+    (i64.load32_u offset=1 align=1 (local.get $$i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32u_good4") (param $$i i64) (result i64)
+    (i64.load32_u offset=2 align=2 (local.get $$i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32u_good5") (param $$i i64) (result i64)
+    (i64.load32_u offset=25 align=4 (local.get $$i))        ;; 122 'z\\0\\0\\0'
+  )
+
+  (func (export "32s_good1") (param $$i i64) (result i64)
+    (i64.load32_s offset=0 (local.get $$i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good2") (param $$i i64) (result i64)
+    (i64.load32_s align=1 (local.get $$i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good3") (param $$i i64) (result i64)
+    (i64.load32_s offset=1 align=1 (local.get $$i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32s_good4") (param $$i i64) (result i64)
+    (i64.load32_s offset=2 align=2 (local.get $$i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32s_good5") (param $$i i64) (result i64)
+    (i64.load32_s offset=25 align=4 (local.get $$i))        ;; 122 'z\\0\\0\\0'
+  )
+
+  (func (export "64_good1") (param $$i i64) (result i64)
+    (i64.load offset=0 (local.get $$i))                     ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good2") (param $$i i64) (result i64)
+    (i64.load align=1 (local.get $$i))                      ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good3") (param $$i i64) (result i64)
+    (i64.load offset=1 align=1 (local.get $$i))             ;; 0x6968676665646362 'bcdefghi'
+  )
+  (func (export "64_good4") (param $$i i64) (result i64)
+    (i64.load offset=2 align=2 (local.get $$i))             ;; 0x6a69686766656463 'cdefghij'
+  )
+  (func (export "64_good5") (param $$i i64) (result i64)
+    (i64.load offset=25 align=8 (local.get $$i))            ;; 122 'z\\0\\0\\0\\0\\0\\0\\0'
+  )
+
+  (func (export "8u_bad") (param $$i i64)
+    (drop (i64.load8_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "8s_bad") (param $$i i64)
+    (drop (i64.load8_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16u_bad") (param $$i i64)
+    (drop (i64.load16_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16s_bad") (param $$i i64)
+    (drop (i64.load16_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "32u_bad") (param $$i i64)
+    (drop (i64.load32_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "32s_bad") (param $$i i64)
+    (drop (i64.load32_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "64_bad") (param $$i i64)
+    (drop (i64.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address64.wast:348
+assert_return(() => invoke($1, `8u_good1`, [0n]), [value("i64", 97n)]);
+
+// ./test/core/address64.wast:349
+assert_return(() => invoke($1, `8u_good2`, [0n]), [value("i64", 97n)]);
+
+// ./test/core/address64.wast:350
+assert_return(() => invoke($1, `8u_good3`, [0n]), [value("i64", 98n)]);
+
+// ./test/core/address64.wast:351
+assert_return(() => invoke($1, `8u_good4`, [0n]), [value("i64", 99n)]);
+
+// ./test/core/address64.wast:352
+assert_return(() => invoke($1, `8u_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:354
+assert_return(() => invoke($1, `8s_good1`, [0n]), [value("i64", 97n)]);
+
+// ./test/core/address64.wast:355
+assert_return(() => invoke($1, `8s_good2`, [0n]), [value("i64", 97n)]);
+
+// ./test/core/address64.wast:356
+assert_return(() => invoke($1, `8s_good3`, [0n]), [value("i64", 98n)]);
+
+// ./test/core/address64.wast:357
+assert_return(() => invoke($1, `8s_good4`, [0n]), [value("i64", 99n)]);
+
+// ./test/core/address64.wast:358
+assert_return(() => invoke($1, `8s_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:360
+assert_return(() => invoke($1, `16u_good1`, [0n]), [value("i64", 25185n)]);
+
+// ./test/core/address64.wast:361
+assert_return(() => invoke($1, `16u_good2`, [0n]), [value("i64", 25185n)]);
+
+// ./test/core/address64.wast:362
+assert_return(() => invoke($1, `16u_good3`, [0n]), [value("i64", 25442n)]);
+
+// ./test/core/address64.wast:363
+assert_return(() => invoke($1, `16u_good4`, [0n]), [value("i64", 25699n)]);
+
+// ./test/core/address64.wast:364
+assert_return(() => invoke($1, `16u_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:366
+assert_return(() => invoke($1, `16s_good1`, [0n]), [value("i64", 25185n)]);
+
+// ./test/core/address64.wast:367
+assert_return(() => invoke($1, `16s_good2`, [0n]), [value("i64", 25185n)]);
+
+// ./test/core/address64.wast:368
+assert_return(() => invoke($1, `16s_good3`, [0n]), [value("i64", 25442n)]);
+
+// ./test/core/address64.wast:369
+assert_return(() => invoke($1, `16s_good4`, [0n]), [value("i64", 25699n)]);
+
+// ./test/core/address64.wast:370
+assert_return(() => invoke($1, `16s_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:372
+assert_return(() => invoke($1, `32u_good1`, [0n]), [value("i64", 1684234849n)]);
+
+// ./test/core/address64.wast:373
+assert_return(() => invoke($1, `32u_good2`, [0n]), [value("i64", 1684234849n)]);
+
+// ./test/core/address64.wast:374
+assert_return(() => invoke($1, `32u_good3`, [0n]), [value("i64", 1701077858n)]);
+
+// ./test/core/address64.wast:375
+assert_return(() => invoke($1, `32u_good4`, [0n]), [value("i64", 1717920867n)]);
+
+// ./test/core/address64.wast:376
+assert_return(() => invoke($1, `32u_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:378
+assert_return(() => invoke($1, `32s_good1`, [0n]), [value("i64", 1684234849n)]);
+
+// ./test/core/address64.wast:379
+assert_return(() => invoke($1, `32s_good2`, [0n]), [value("i64", 1684234849n)]);
+
+// ./test/core/address64.wast:380
+assert_return(() => invoke($1, `32s_good3`, [0n]), [value("i64", 1701077858n)]);
+
+// ./test/core/address64.wast:381
+assert_return(() => invoke($1, `32s_good4`, [0n]), [value("i64", 1717920867n)]);
+
+// ./test/core/address64.wast:382
+assert_return(() => invoke($1, `32s_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:384
+assert_return(() => invoke($1, `64_good1`, [0n]), [value("i64", 7523094288207667809n)]);
+
+// ./test/core/address64.wast:385
+assert_return(() => invoke($1, `64_good2`, [0n]), [value("i64", 7523094288207667809n)]);
+
+// ./test/core/address64.wast:386
+assert_return(() => invoke($1, `64_good3`, [0n]), [value("i64", 7595434461045744482n)]);
+
+// ./test/core/address64.wast:387
+assert_return(() => invoke($1, `64_good4`, [0n]), [value("i64", 7667774633883821155n)]);
+
+// ./test/core/address64.wast:388
+assert_return(() => invoke($1, `64_good5`, [0n]), [value("i64", 122n)]);
+
+// ./test/core/address64.wast:390
+assert_return(() => invoke($1, `8u_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:391
+assert_return(() => invoke($1, `8u_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:392
+assert_return(() => invoke($1, `8u_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:393
+assert_return(() => invoke($1, `8u_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:394
+assert_return(() => invoke($1, `8u_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:396
+assert_return(() => invoke($1, `8s_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:397
+assert_return(() => invoke($1, `8s_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:398
+assert_return(() => invoke($1, `8s_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:399
+assert_return(() => invoke($1, `8s_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:400
+assert_return(() => invoke($1, `8s_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:402
+assert_return(() => invoke($1, `16u_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:403
+assert_return(() => invoke($1, `16u_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:404
+assert_return(() => invoke($1, `16u_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:405
+assert_return(() => invoke($1, `16u_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:406
+assert_return(() => invoke($1, `16u_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:408
+assert_return(() => invoke($1, `16s_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:409
+assert_return(() => invoke($1, `16s_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:410
+assert_return(() => invoke($1, `16s_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:411
+assert_return(() => invoke($1, `16s_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:412
+assert_return(() => invoke($1, `16s_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:414
+assert_return(() => invoke($1, `32u_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:415
+assert_return(() => invoke($1, `32u_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:416
+assert_return(() => invoke($1, `32u_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:417
+assert_return(() => invoke($1, `32u_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:418
+assert_return(() => invoke($1, `32u_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:420
+assert_return(() => invoke($1, `32s_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:421
+assert_return(() => invoke($1, `32s_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:422
+assert_return(() => invoke($1, `32s_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:423
+assert_return(() => invoke($1, `32s_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:424
+assert_return(() => invoke($1, `32s_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:426
+assert_return(() => invoke($1, `64_good1`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:427
+assert_return(() => invoke($1, `64_good2`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:428
+assert_return(() => invoke($1, `64_good3`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:429
+assert_return(() => invoke($1, `64_good4`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:430
+assert_return(() => invoke($1, `64_good5`, [65503n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:432
+assert_return(() => invoke($1, `8u_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:433
+assert_return(() => invoke($1, `8u_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:434
+assert_return(() => invoke($1, `8u_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:435
+assert_return(() => invoke($1, `8u_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:436
+assert_return(() => invoke($1, `8u_good5`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:438
+assert_return(() => invoke($1, `8s_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:439
+assert_return(() => invoke($1, `8s_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:440
+assert_return(() => invoke($1, `8s_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:441
+assert_return(() => invoke($1, `8s_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:442
+assert_return(() => invoke($1, `8s_good5`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:444
+assert_return(() => invoke($1, `16u_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:445
+assert_return(() => invoke($1, `16u_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:446
+assert_return(() => invoke($1, `16u_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:447
+assert_return(() => invoke($1, `16u_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:448
+assert_return(() => invoke($1, `16u_good5`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:450
+assert_return(() => invoke($1, `16s_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:451
+assert_return(() => invoke($1, `16s_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:452
+assert_return(() => invoke($1, `16s_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:453
+assert_return(() => invoke($1, `16s_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:454
+assert_return(() => invoke($1, `16s_good5`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:456
+assert_return(() => invoke($1, `32u_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:457
+assert_return(() => invoke($1, `32u_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:458
+assert_return(() => invoke($1, `32u_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:459
+assert_return(() => invoke($1, `32u_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:460
+assert_return(() => invoke($1, `32u_good5`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:462
+assert_return(() => invoke($1, `32s_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:463
+assert_return(() => invoke($1, `32s_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:464
+assert_return(() => invoke($1, `32s_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:465
+assert_return(() => invoke($1, `32s_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:466
+assert_return(() => invoke($1, `32s_good5`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:468
+assert_return(() => invoke($1, `64_good1`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:469
+assert_return(() => invoke($1, `64_good2`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:470
+assert_return(() => invoke($1, `64_good3`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:471
+assert_return(() => invoke($1, `64_good4`, [65504n]), [value("i64", 0n)]);
+
+// ./test/core/address64.wast:472
+assert_trap(() => invoke($1, `64_good5`, [65504n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:474
+assert_trap(() => invoke($1, `8u_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:475
+assert_trap(() => invoke($1, `8s_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:476
+assert_trap(() => invoke($1, `16u_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:477
+assert_trap(() => invoke($1, `16s_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:478
+assert_trap(() => invoke($1, `32u_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:479
+assert_trap(() => invoke($1, `32s_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:480
+assert_trap(() => invoke($1, `64_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:482
+assert_trap(() => invoke($1, `8u_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:483
+assert_trap(() => invoke($1, `8s_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:484
+assert_trap(() => invoke($1, `16u_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:485
+assert_trap(() => invoke($1, `16s_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:486
+assert_trap(() => invoke($1, `32u_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:487
+assert_trap(() => invoke($1, `32s_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:488
+assert_trap(() => invoke($1, `64_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:492
+let $2 = instantiate(`(module
+  (memory i64 1)
+  (data (i64.const 0) "\\00\\00\\00\\00\\00\\00\\a0\\7f\\01\\00\\d0\\7f")
+
+  (func (export "32_good1") (param $$i i64) (result f32)
+    (f32.load offset=0 (local.get $$i))                   ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good2") (param $$i i64) (result f32)
+    (f32.load align=1 (local.get $$i))                    ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good3") (param $$i i64) (result f32)
+    (f32.load offset=1 align=1 (local.get $$i))           ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good4") (param $$i i64) (result f32)
+    (f32.load offset=2 align=2 (local.get $$i))           ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good5") (param $$i i64) (result f32)
+    (f32.load offset=8 align=4 (local.get $$i))           ;; nan:0x500001 '\\01\\00\\d0\\7f'
+  )
+  (func (export "32_bad") (param $$i i64)
+    (drop (f32.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address64.wast:516
+assert_return(() => invoke($2, `32_good1`, [0n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:517
+assert_return(() => invoke($2, `32_good2`, [0n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:518
+assert_return(() => invoke($2, `32_good3`, [0n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:519
+assert_return(() => invoke($2, `32_good4`, [0n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:520
+assert_return(() => invoke($2, `32_good5`, [0n]), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/address64.wast:522
+assert_return(() => invoke($2, `32_good1`, [65524n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:523
+assert_return(() => invoke($2, `32_good2`, [65524n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:524
+assert_return(() => invoke($2, `32_good3`, [65524n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:525
+assert_return(() => invoke($2, `32_good4`, [65524n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:526
+assert_return(() => invoke($2, `32_good5`, [65524n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:528
+assert_return(() => invoke($2, `32_good1`, [65525n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:529
+assert_return(() => invoke($2, `32_good2`, [65525n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:530
+assert_return(() => invoke($2, `32_good3`, [65525n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:531
+assert_return(() => invoke($2, `32_good4`, [65525n]), [value("f32", 0)]);
+
+// ./test/core/address64.wast:532
+assert_trap(() => invoke($2, `32_good5`, [65525n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:534
+assert_trap(() => invoke($2, `32_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:535
+assert_trap(() => invoke($2, `32_bad`, [1n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:539
+let $3 = instantiate(`(module
+  (memory i64 1)
+  (data (i64.const 0) "\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\f4\\7f\\01\\00\\00\\00\\00\\00\\fc\\7f")
+
+  (func (export "64_good1") (param $$i i64) (result f64)
+    (f64.load offset=0 (local.get $$i))                     ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good2") (param $$i i64) (result f64)
+    (f64.load align=1 (local.get $$i))                      ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good3") (param $$i i64) (result f64)
+    (f64.load offset=1 align=1 (local.get $$i))             ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good4") (param $$i i64) (result f64)
+    (f64.load offset=2 align=2 (local.get $$i))             ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good5") (param $$i i64) (result f64)
+    (f64.load offset=18 align=8 (local.get $$i))            ;; nan:0xc000000000001 '\\01\\00\\00\\00\\00\\00\\fc\\7f'
+  )
+  (func (export "64_bad") (param $$i i64)
+    (drop (f64.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address64.wast:563
+assert_return(() => invoke($3, `64_good1`, [0n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:564
+assert_return(() => invoke($3, `64_good2`, [0n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:565
+assert_return(() => invoke($3, `64_good3`, [0n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:566
+assert_return(() => invoke($3, `64_good4`, [0n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:567
+assert_return(
+  () => invoke($3, `64_good5`, [0n]),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
+
+// ./test/core/address64.wast:569
+assert_return(() => invoke($3, `64_good1`, [65510n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:570
+assert_return(() => invoke($3, `64_good2`, [65510n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:571
+assert_return(() => invoke($3, `64_good3`, [65510n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:572
+assert_return(() => invoke($3, `64_good4`, [65510n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:573
+assert_return(() => invoke($3, `64_good5`, [65510n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:575
+assert_return(() => invoke($3, `64_good1`, [65511n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:576
+assert_return(() => invoke($3, `64_good2`, [65511n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:577
+assert_return(() => invoke($3, `64_good3`, [65511n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:578
+assert_return(() => invoke($3, `64_good4`, [65511n]), [value("f64", 0)]);
+
+// ./test/core/address64.wast:579
+assert_trap(() => invoke($3, `64_good5`, [65511n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:581
+assert_trap(() => invoke($3, `64_bad`, [0n]), `out of bounds memory access`);
+
+// ./test/core/address64.wast:582
+assert_trap(() => invoke($3, `64_bad`, [1n]), `out of bounds memory access`);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js
new file mode 100644
index 0000000000..34b4990f8f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/align64.wast.js
@@ -0,0 +1,1090 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/align64.wast
+
+// ./test/core/align64.wast:3
+let $0 = instantiate(`(module (memory i64 0) (func (drop (i32.load8_s align=1 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:4
+let $1 = instantiate(`(module (memory i64 0) (func (drop (i32.load8_u align=1 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:5
+let $2 = instantiate(`(module (memory i64 0) (func (drop (i32.load16_s align=2 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:6
+let $3 = instantiate(`(module (memory i64 0) (func (drop (i32.load16_u align=2 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:7
+let $4 = instantiate(`(module (memory i64 0) (func (drop (i32.load align=4 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:8
+let $5 = instantiate(`(module (memory i64 0) (func (drop (i64.load8_s align=1 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:9
+let $6 = instantiate(`(module (memory i64 0) (func (drop (i64.load8_u align=1 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:10
+let $7 = instantiate(`(module (memory i64 0) (func (drop (i64.load16_s align=2 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:11
+let $8 = instantiate(`(module (memory i64 0) (func (drop (i64.load16_u align=2 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:12
+let $9 = instantiate(`(module (memory i64 0) (func (drop (i64.load32_s align=4 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:13
+let $10 = instantiate(`(module (memory i64 0) (func (drop (i64.load32_u align=4 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:14
+let $11 = instantiate(`(module (memory i64 0) (func (drop (i64.load align=8 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:15
+let $12 = instantiate(`(module (memory i64 0) (func (drop (f32.load align=4 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:16
+let $13 = instantiate(`(module (memory i64 0) (func (drop (f64.load align=8 (i64.const 0)))))`);
+
+// ./test/core/align64.wast:17
+let $14 = instantiate(`(module (memory i64 0) (func (i32.store8 align=1 (i64.const 0) (i32.const 1))))`);
+
+// ./test/core/align64.wast:18
+let $15 = instantiate(`(module (memory i64 0) (func (i32.store16 align=2 (i64.const 0) (i32.const 1))))`);
+
+// ./test/core/align64.wast:19
+let $16 = instantiate(`(module (memory i64 0) (func (i32.store align=4 (i64.const 0) (i32.const 1))))`);
+
+// ./test/core/align64.wast:20
+let $17 = instantiate(`(module (memory i64 0) (func (i64.store8 align=1 (i64.const 0) (i64.const 1))))`);
+
+// ./test/core/align64.wast:21
+let $18 = instantiate(`(module (memory i64 0) (func (i64.store16 align=2 (i64.const 0) (i64.const 1))))`);
+
+// ./test/core/align64.wast:22
+let $19 = instantiate(`(module (memory i64 0) (func (i64.store32 align=4 (i64.const 0) (i64.const 1))))`);
+
+// ./test/core/align64.wast:23
+let $20 = instantiate(`(module (memory i64 0) (func (i64.store align=8 (i64.const 0) (i64.const 1))))`);
+
+// ./test/core/align64.wast:24
+let $21 = instantiate(`(module (memory i64 0) (func (f32.store align=4 (i64.const 0) (f32.const 1.0))))`);
+
+// ./test/core/align64.wast:25
+let $22 = instantiate(`(module (memory i64 0) (func (f64.store align=8 (i64.const 0) (f64.const 1.0))))`);
+
+// ./test/core/align64.wast:27
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_s align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:33
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_s align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:39
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_u align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:45
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_u align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:51
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_s align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:57
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_s align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:63
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_u align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:69
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_u align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:75
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:81
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:87
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_s align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:93
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_s align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:99
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_u align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:105
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_u align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:111
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_s align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:117
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_s align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:123
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_u align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:129
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_u align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:135
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_s align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:141
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_s align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:147
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_u align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:153
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_u align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:159
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:165
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:171
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (f32.load align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:177
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (f32.load align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:183
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (f64.load align=0 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:189
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (drop (f64.load align=7 (i64.const 0))))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:196
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i32.store8 align=0 (i64.const 0) (i32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:202
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i32.store8 align=7 (i64.const 0) (i32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:208
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i32.store16 align=0 (i64.const 0) (i32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:214
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i32.store16 align=7 (i64.const 0) (i32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:220
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i32.store align=0 (i64.const 0) (i32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:226
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i32.store align=7 (i64.const 0) (i32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:232
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store8 align=0 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:238
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store8 align=7 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:244
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store16 align=0 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:250
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store16 align=7 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:256
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store32 align=0 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:262
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store32 align=7 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:268
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store align=0 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:274
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (i64.store align=7 (i64.const 0) (i64.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:280
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (f32.store align=0 (i64.const 0) (f32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:286
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (f32.store align=7 (i64.const 0) (f32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:292
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (f64.store align=0 (i64.const 0) (f32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:298
+assert_malformed(
+  () => instantiate(`(module (memory i64 0) (func (f64.store align=7 (i64.const 0) (f32.const 0)))) `),
+  `alignment`,
+);
+
+// ./test/core/align64.wast:305
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_s align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:309
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_u align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:313
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_s align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:317
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_u align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:321
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:325
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_s align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:329
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_u align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:333
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_s align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:337
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_u align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:341
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_s align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:345
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_u align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:349
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load align=16 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:353
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (f32.load align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:357
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (f64.load align=16 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:362
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_s align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:366
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load8_u align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:370
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_s align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:374
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load16_u align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:378
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i32.load align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:382
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_s align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:386
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load8_u align=2 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:390
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_s align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:394
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load16_u align=4 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:398
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_s align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:402
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load32_u align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:406
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (i64.load align=16 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:410
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (f32.load align=8 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:414
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (drop (f64.load align=16 (i64.const 0)))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:419
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i32.store8 align=2 (i64.const 0) (i32.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:423
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i32.store16 align=4 (i64.const 0) (i32.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:427
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i32.store align=8 (i64.const 0) (i32.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:431
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i64.store8 align=2 (i64.const 0) (i64.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:435
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i64.store16 align=4 (i64.const 0) (i64.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:439
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i64.store32 align=8 (i64.const 0) (i64.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:443
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (i64.store align=16 (i64.const 0) (i64.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:447
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (f32.store align=8 (i64.const 0) (f32.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:451
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (func (f64.store align=16 (i64.const 0) (f64.const 0))))`),
+  `alignment must not be larger than natural`,
+);
+
+// ./test/core/align64.wast:458
+let $23 = instantiate(`(module
+  (memory i64 1)
+
+  ;; $$default: natural alignment, $$1: align=1, $$2: align=2, $$4: align=4, $$8: align=8
+
+  (func (export "f32_align_switch") (param i32) (result f32)
+    (local f32 f32)
+    (local.set 1 (f32.const 10.0))
+    (block $$4
+      (block $$2
+        (block $$1
+          (block $$default
+            (block $$0
+              (br_table $$0 $$default $$1 $$2 $$4 (local.get 0))
+            ) ;; 0
+            (f32.store (i64.const 0) (local.get 1))
+            (local.set 2 (f32.load (i64.const 0)))
+            (br $$4)
+          ) ;; default
+          (f32.store align=1 (i64.const 0) (local.get 1))
+          (local.set 2 (f32.load align=1 (i64.const 0)))
+          (br $$4)
+        ) ;; 1
+        (f32.store align=2 (i64.const 0) (local.get 1))
+        (local.set 2 (f32.load align=2 (i64.const 0)))
+        (br $$4)
+      ) ;; 2
+      (f32.store align=4 (i64.const 0) (local.get 1))
+      (local.set 2 (f32.load align=4 (i64.const 0)))
+    ) ;; 4
+    (local.get 2)
+  )
+
+  (func (export "f64_align_switch") (param i32) (result f64)
+    (local f64 f64)
+    (local.set 1 (f64.const 10.0))
+    (block $$8
+      (block $$4
+        (block $$2
+          (block $$1
+            (block $$default
+              (block $$0
+                (br_table $$0 $$default $$1 $$2 $$4 $$8 (local.get 0))
+              ) ;; 0
+              (f64.store (i64.const 0) (local.get 1))
+              (local.set 2 (f64.load (i64.const 0)))
+              (br $$8)
+            ) ;; default
+            (f64.store align=1 (i64.const 0) (local.get 1))
+            (local.set 2 (f64.load align=1 (i64.const 0)))
+            (br $$8)
+          ) ;; 1
+          (f64.store align=2 (i64.const 0) (local.get 1))
+          (local.set 2 (f64.load align=2 (i64.const 0)))
+          (br $$8)
+        ) ;; 2
+        (f64.store align=4 (i64.const 0) (local.get 1))
+        (local.set 2 (f64.load align=4 (i64.const 0)))
+        (br $$8)
+      ) ;; 4
+      (f64.store align=8 (i64.const 0) (local.get 1))
+      (local.set 2 (f64.load align=8 (i64.const 0)))
+    ) ;; 8
+    (local.get 2)
+  )
+
+  ;; $$8s: i32/i64.load8_s, $$8u: i32/i64.load8_u, $$16s: i32/i64.load16_s, $$16u: i32/i64.load16_u, $$32: i32.load
+  ;; $$32s: i64.load32_s, $$32u: i64.load32_u, $$64: i64.load
+
+  (func (export "i32_align_switch") (param i32 i32) (result i32)
+    (local i32 i32)
+    (local.set 2 (i32.const 10))
+    (block $$32
+      (block $$16u
+        (block $$16s
+          (block $$8u
+            (block $$8s
+              (block $$0
+                (br_table $$0 $$8s $$8u $$16s $$16u $$32 (local.get 0))
+              ) ;; 0
+              (if (i32.eq (local.get 1) (i32.const 0))
+                (then
+                  (i32.store8 (i64.const 0) (local.get 2))
+                  (local.set 3 (i32.load8_s (i64.const 0)))
+                )
+              )
+              (if (i32.eq (local.get 1) (i32.const 1))
+                (then
+                  (i32.store8 align=1 (i64.const 0) (local.get 2))
+                  (local.set 3 (i32.load8_s align=1 (i64.const 0)))
+                )
+              )
+              (br $$32)
+            ) ;; 8s
+            (if (i32.eq (local.get 1) (i32.const 0))
+              (then
+                (i32.store8 (i64.const 0) (local.get 2))
+                (local.set 3 (i32.load8_u (i64.const 0)))
+              )
+            )
+            (if (i32.eq (local.get 1) (i32.const 1))
+              (then
+                (i32.store8 align=1 (i64.const 0) (local.get 2))
+                (local.set 3 (i32.load8_u align=1 (i64.const 0)))
+              )
+            )
+            (br $$32)
+          ) ;; 8u
+          (if (i32.eq (local.get 1) (i32.const 0))
+            (then
+              (i32.store16 (i64.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s (i64.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 1))
+            (then
+              (i32.store16 align=1 (i64.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s align=1 (i64.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 2))
+            (then
+              (i32.store16 align=2 (i64.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s align=2 (i64.const 0)))
+            )
+          )
+          (br $$32)
+        ) ;; 16s
+        (if (i32.eq (local.get 1) (i32.const 0))
+          (then
+            (i32.store16 (i64.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u (i64.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 1))
+          (then
+            (i32.store16 align=1 (i64.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u align=1 (i64.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 2))
+          (then
+            (i32.store16 align=2 (i64.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u align=2 (i64.const 0)))
+          )
+        )
+        (br $$32)
+      ) ;; 16u
+      (if (i32.eq (local.get 1) (i32.const 0))
+        (then
+          (i32.store (i64.const 0) (local.get 2))
+          (local.set 3 (i32.load (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 1))
+        (then
+          (i32.store align=1 (i64.const 0) (local.get 2))
+          (local.set 3 (i32.load align=1 (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 2))
+        (then
+          (i32.store align=2 (i64.const 0) (local.get 2))
+          (local.set 3 (i32.load align=2 (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 4))
+        (then
+          (i32.store align=4 (i64.const 0) (local.get 2))
+          (local.set 3 (i32.load align=4 (i64.const 0)))
+        )
+      )
+    ) ;; 32
+    (local.get 3)
+  )
+
+  (func (export "i64_align_switch") (param i32 i32) (result i64)
+    (local i64 i64)
+    (local.set 2 (i64.const 10))
+    (block $$64
+      (block $$32u
+        (block $$32s
+          (block $$16u
+            (block $$16s
+              (block $$8u
+                (block $$8s
+                  (block $$0
+                    (br_table $$0 $$8s $$8u $$16s $$16u $$32s $$32u $$64 (local.get 0))
+                  ) ;; 0
+                  (if (i32.eq (local.get 1) (i32.const 0))
+                    (then
+                      (i64.store8 (i64.const 0) (local.get 2))
+                      (local.set 3 (i64.load8_s (i64.const 0)))
+                    )
+                  )
+                  (if (i32.eq (local.get 1) (i32.const 1))
+                    (then
+                      (i64.store8 align=1 (i64.const 0) (local.get 2))
+                      (local.set 3 (i64.load8_s align=1 (i64.const 0)))
+                    )
+                  )
+                  (br $$64)
+                ) ;; 8s
+                (if (i32.eq (local.get 1) (i32.const 0))
+                  (then
+                    (i64.store8 (i64.const 0) (local.get 2))
+                    (local.set 3 (i64.load8_u (i64.const 0)))
+                  )
+                )
+                (if (i32.eq (local.get 1) (i32.const 1))
+                  (then
+                    (i64.store8 align=1 (i64.const 0) (local.get 2))
+                    (local.set 3 (i64.load8_u align=1 (i64.const 0)))
+                  )
+                )
+                (br $$64)
+              ) ;; 8u
+              (if (i32.eq (local.get 1) (i32.const 0))
+                (then
+                  (i64.store16 (i64.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s (i64.const 0)))
+                )
+              )
+              (if (i32.eq (local.get 1) (i32.const 1))
+                (then
+                  (i64.store16 align=1 (i64.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s align=1 (i64.const 0)))
+                )
+              )
+              (if (i32.eq (local.get 1) (i32.const 2))
+                (then
+                  (i64.store16 align=2 (i64.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s align=2 (i64.const 0)))
+                )
+              )
+              (br $$64)
+            ) ;; 16s
+            (if (i32.eq (local.get 1) (i32.const 0))
+              (then
+                (i64.store16 (i64.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u (i64.const 0)))
+              )
+            )
+            (if (i32.eq (local.get 1) (i32.const 1))
+              (then
+                (i64.store16 align=1 (i64.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u align=1 (i64.const 0)))
+              )
+            )
+            (if (i32.eq (local.get 1) (i32.const 2))
+              (then
+                (i64.store16 align=2 (i64.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u align=2 (i64.const 0)))
+              )
+            )
+            (br $$64)
+          ) ;; 16u
+          (if (i32.eq (local.get 1) (i32.const 0))
+            (then
+              (i64.store32 (i64.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s (i64.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 1))
+            (then
+              (i64.store32 align=1 (i64.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=1 (i64.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 2))
+            (then
+              (i64.store32 align=2 (i64.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=2 (i64.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 4))
+            (then
+              (i64.store32 align=4 (i64.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=4 (i64.const 0)))
+            )
+          )
+          (br $$64)
+        ) ;; 32s
+        (if (i32.eq (local.get 1) (i32.const 0))
+          (then
+            (i64.store32 (i64.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u (i64.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 1))
+          (then
+            (i64.store32 align=1 (i64.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=1 (i64.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 2))
+          (then
+            (i64.store32 align=2 (i64.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=2 (i64.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 4))
+          (then
+            (i64.store32 align=4 (i64.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=4 (i64.const 0)))
+          )
+        )
+        (br $$64)
+      ) ;; 32u
+      (if (i32.eq (local.get 1) (i32.const 0))
+        (then
+          (i64.store (i64.const 0) (local.get 2))
+          (local.set 3 (i64.load (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 1))
+        (then
+          (i64.store align=1 (i64.const 0) (local.get 2))
+          (local.set 3 (i64.load align=1 (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 2))
+        (then
+          (i64.store align=2 (i64.const 0) (local.get 2))
+          (local.set 3 (i64.load align=2 (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 4))
+        (then
+          (i64.store align=4 (i64.const 0) (local.get 2))
+          (local.set 3 (i64.load align=4 (i64.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 8))
+        (then
+          (i64.store align=8 (i64.const 0) (local.get 2))
+          (local.set 3 (i64.load align=8 (i64.const 0)))
+        )
+      )
+    ) ;; 64
+    (local.get 3)
+  )
+)`);
+
+// ./test/core/align64.wast:802
+assert_return(() => invoke($23, `f32_align_switch`, [0]), [value("f32", 10)]);
+
+// ./test/core/align64.wast:803
+assert_return(() => invoke($23, `f32_align_switch`, [1]), [value("f32", 10)]);
+
+// ./test/core/align64.wast:804
+assert_return(() => invoke($23, `f32_align_switch`, [2]), [value("f32", 10)]);
+
+// ./test/core/align64.wast:805
+assert_return(() => invoke($23, `f32_align_switch`, [3]), [value("f32", 10)]);
+
+// ./test/core/align64.wast:807
+assert_return(() => invoke($23, `f64_align_switch`, [0]), [value("f64", 10)]);
+
+// ./test/core/align64.wast:808
+assert_return(() => invoke($23, `f64_align_switch`, [1]), [value("f64", 10)]);
+
+// ./test/core/align64.wast:809
+assert_return(() => invoke($23, `f64_align_switch`, [2]), [value("f64", 10)]);
+
+// ./test/core/align64.wast:810
+assert_return(() => invoke($23, `f64_align_switch`, [3]), [value("f64", 10)]);
+
+// ./test/core/align64.wast:811
+assert_return(() => invoke($23, `f64_align_switch`, [4]), [value("f64", 10)]);
+
+// ./test/core/align64.wast:813
+assert_return(() => invoke($23, `i32_align_switch`, [0, 0]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:814
+assert_return(() => invoke($23, `i32_align_switch`, [0, 1]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:815
+assert_return(() => invoke($23, `i32_align_switch`, [1, 0]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:816
+assert_return(() => invoke($23, `i32_align_switch`, [1, 1]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:817
+assert_return(() => invoke($23, `i32_align_switch`, [2, 0]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:818
+assert_return(() => invoke($23, `i32_align_switch`, [2, 1]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:819
+assert_return(() => invoke($23, `i32_align_switch`, [2, 2]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:820
+assert_return(() => invoke($23, `i32_align_switch`, [3, 0]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:821
+assert_return(() => invoke($23, `i32_align_switch`, [3, 1]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:822
+assert_return(() => invoke($23, `i32_align_switch`, [3, 2]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:823
+assert_return(() => invoke($23, `i32_align_switch`, [4, 0]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:824
+assert_return(() => invoke($23, `i32_align_switch`, [4, 1]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:825
+assert_return(() => invoke($23, `i32_align_switch`, [4, 2]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:826
+assert_return(() => invoke($23, `i32_align_switch`, [4, 4]), [value("i32", 10)]);
+
+// ./test/core/align64.wast:828
+assert_return(() => invoke($23, `i64_align_switch`, [0, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:829
+assert_return(() => invoke($23, `i64_align_switch`, [0, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:830
+assert_return(() => invoke($23, `i64_align_switch`, [1, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:831
+assert_return(() => invoke($23, `i64_align_switch`, [1, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:832
+assert_return(() => invoke($23, `i64_align_switch`, [2, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:833
+assert_return(() => invoke($23, `i64_align_switch`, [2, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:834
+assert_return(() => invoke($23, `i64_align_switch`, [2, 2]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:835
+assert_return(() => invoke($23, `i64_align_switch`, [3, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:836
+assert_return(() => invoke($23, `i64_align_switch`, [3, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:837
+assert_return(() => invoke($23, `i64_align_switch`, [3, 2]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:838
+assert_return(() => invoke($23, `i64_align_switch`, [4, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:839
+assert_return(() => invoke($23, `i64_align_switch`, [4, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:840
+assert_return(() => invoke($23, `i64_align_switch`, [4, 2]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:841
+assert_return(() => invoke($23, `i64_align_switch`, [4, 4]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:842
+assert_return(() => invoke($23, `i64_align_switch`, [5, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:843
+assert_return(() => invoke($23, `i64_align_switch`, [5, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:844
+assert_return(() => invoke($23, `i64_align_switch`, [5, 2]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:845
+assert_return(() => invoke($23, `i64_align_switch`, [5, 4]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:846
+assert_return(() => invoke($23, `i64_align_switch`, [6, 0]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:847
+assert_return(() => invoke($23, `i64_align_switch`, [6, 1]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:848
+assert_return(() => invoke($23, `i64_align_switch`, [6, 2]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:849
+assert_return(() => invoke($23, `i64_align_switch`, [6, 4]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:850
+assert_return(() => invoke($23, `i64_align_switch`, [6, 8]), [value("i64", 10n)]);
+
+// ./test/core/align64.wast:854
+let $24 = instantiate(`(module
+  (memory i64 1)
+  (func (export "store") (param i64 i64)
+    (i64.store align=4 (local.get 0) (local.get 1))
+  )
+  (func (export "load") (param i64) (result i32)
+    (i32.load (local.get 0))
+  )
+)`);
+
+// Bug 1737225 - do not observe the partial store caused by bug 1666747 on
+// some native platforms.
+if (!partialOobWriteMayWritePartialData()) {
+    // ./test/core/align64.wast:864
+    assert_trap(
+        () => invoke($24, `store`, [65532n, -1n]),
+        `out of bounds memory access`,
+    );
+
+    // ./test/core/align64.wast:866
+    assert_return(() => invoke($24, `load`, [65532n]), [value("i32", 0)]);
+}
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/directives.txt b/js/src/jit-test/tests/wasm/spec/memory64/directives.txt
new file mode 100644
index 0000000000..bbc47fb788
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; skip-if: !wasmMemory64Enabled()
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/endianness64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/endianness64.wast.js
new file mode 100644
index 0000000000..651714be6f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/endianness64.wast.js
@@ -0,0 +1,385 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/endianness64.wast
+
+// ./test/core/endianness64.wast:1
+let $0 = instantiate(`(module
+  (memory i64 1)
+
+  ;; Stores an i16 value in little-endian-format
+  (func $$i16_store_little (param $$address i64) (param $$value i32)
+    (i32.store8 (local.get $$address) (local.get $$value))
+    (i32.store8 (i64.add (local.get $$address) (i64.const 1)) (i32.shr_u (local.get $$value) (i32.const 8)))
+  )
+
+  ;; Stores an i32 value in little-endian format
+  (func $$i32_store_little (param $$address i64) (param $$value i32)
+    (call $$i16_store_little (local.get $$address) (local.get $$value))
+    (call $$i16_store_little (i64.add (local.get $$address) (i64.const 2)) (i32.shr_u (local.get $$value) (i32.const 16)))
+  )
+
+  ;; Stores an i64 value in little-endian format
+  (func $$i64_store_little (param $$address i64) (param $$value i64)
+    (call $$i32_store_little (local.get $$address) (i32.wrap_i64 (local.get $$value)))
+    (call $$i32_store_little (i64.add (local.get $$address) (i64.const 4)) (i32.wrap_i64 (i64.shr_u (local.get $$value) (i64.const 32))))
+  )
+
+  ;; Loads an i16 value in little-endian format
+  (func $$i16_load_little (param $$address i64) (result i32)
+    (i32.or
+      (i32.load8_u (local.get $$address))
+      (i32.shl (i32.load8_u (i64.add (local.get $$address) (i64.const 1))) (i32.const 8))
+    )
+  )
+
+  ;; Loads an i32 value in little-endian format
+  (func $$i32_load_little (param $$address i64) (result i32)
+    (i32.or
+      (call $$i16_load_little (local.get $$address))
+      (i32.shl (call $$i16_load_little (i64.add (local.get $$address) (i64.const 2))) (i32.const 16))
+    )
+  )
+
+  ;; Loads an i64 value in little-endian format
+  (func $$i64_load_little (param $$address i64) (result i64)
+    (i64.or
+      (i64.extend_i32_u (call $$i32_load_little (local.get $$address)))
+      (i64.shl (i64.extend_i32_u (call $$i32_load_little (i64.add (local.get $$address) (i64.const 4)))) (i64.const 32))
+    )
+  )
+
+  (func (export "i32_load16_s") (param $$value i32) (result i32)
+    (call $$i16_store_little (i64.const 0) (local.get $$value))
+    (i32.load16_s (i64.const 0))
+  )
+
+  (func (export "i32_load16_u") (param $$value i32) (result i32)
+    (call $$i16_store_little (i64.const 0) (local.get $$value))
+    (i32.load16_u (i64.const 0))
+  )
+
+  (func (export "i32_load") (param $$value i32) (result i32)
+    (call $$i32_store_little (i64.const 0) (local.get $$value))
+    (i32.load (i64.const 0))
+  )
+
+  (func (export "i64_load16_s") (param $$value i64) (result i64)
+    (call $$i16_store_little (i64.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load16_s (i64.const 0))
+  )
+
+  (func (export "i64_load16_u") (param $$value i64) (result i64)
+    (call $$i16_store_little (i64.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load16_u (i64.const 0))
+  )
+
+  (func (export "i64_load32_s") (param $$value i64) (result i64)
+    (call $$i32_store_little (i64.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load32_s (i64.const 0))
+  )
+
+  (func (export "i64_load32_u") (param $$value i64) (result i64)
+    (call $$i32_store_little (i64.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load32_u (i64.const 0))
+  )
+
+  (func (export "i64_load") (param $$value i64) (result i64)
+    (call $$i64_store_little (i64.const 0) (local.get $$value))
+    (i64.load (i64.const 0))
+  )
+
+  (func (export "f32_load") (param $$value f32) (result f32)
+    (call $$i32_store_little (i64.const 0) (i32.reinterpret_f32 (local.get $$value)))
+    (f32.load (i64.const 0))
+  )
+
+  (func (export "f64_load") (param $$value f64) (result f64)
+    (call $$i64_store_little (i64.const 0) (i64.reinterpret_f64 (local.get $$value)))
+    (f64.load (i64.const 0))
+  )
+
+
+  (func (export "i32_store16") (param $$value i32) (result i32)
+    (i32.store16 (i64.const 0) (local.get $$value))
+    (call $$i16_load_little (i64.const 0))
+  )
+
+  (func (export "i32_store") (param $$value i32) (result i32)
+    (i32.store (i64.const 0) (local.get $$value))
+    (call $$i32_load_little (i64.const 0))
+  )
+
+  (func (export "i64_store16") (param $$value i64) (result i64)
+    (i64.store16 (i64.const 0) (local.get $$value))
+    (i64.extend_i32_u (call $$i16_load_little (i64.const 0)))
+  )
+
+  (func (export "i64_store32") (param $$value i64) (result i64)
+    (i64.store32 (i64.const 0) (local.get $$value))
+    (i64.extend_i32_u (call $$i32_load_little (i64.const 0)))
+  )
+
+  (func (export "i64_store") (param $$value i64) (result i64)
+    (i64.store (i64.const 0) (local.get $$value))
+    (call $$i64_load_little (i64.const 0))
+  )
+
+  (func (export "f32_store") (param $$value f32) (result f32)
+    (f32.store (i64.const 0) (local.get $$value))
+    (f32.reinterpret_i32 (call $$i32_load_little (i64.const 0)))
+  )
+
+  (func (export "f64_store") (param $$value f64) (result f64)
+    (f64.store (i64.const 0) (local.get $$value))
+    (f64.reinterpret_i64 (call $$i64_load_little (i64.const 0)))
+  )
+)`);
+
+// ./test/core/endianness64.wast:133
+assert_return(() => invoke($0, `i32_load16_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/endianness64.wast:134
+assert_return(() => invoke($0, `i32_load16_s`, [-4242]), [value("i32", -4242)]);
+
+// ./test/core/endianness64.wast:135
+assert_return(() => invoke($0, `i32_load16_s`, [42]), [value("i32", 42)]);
+
+// ./test/core/endianness64.wast:136
+assert_return(() => invoke($0, `i32_load16_s`, [12816]), [value("i32", 12816)]);
+
+// ./test/core/endianness64.wast:138
+assert_return(() => invoke($0, `i32_load16_u`, [-1]), [value("i32", 65535)]);
+
+// ./test/core/endianness64.wast:139
+assert_return(() => invoke($0, `i32_load16_u`, [-4242]), [value("i32", 61294)]);
+
+// ./test/core/endianness64.wast:140
+assert_return(() => invoke($0, `i32_load16_u`, [42]), [value("i32", 42)]);
+
+// ./test/core/endianness64.wast:141
+assert_return(() => invoke($0, `i32_load16_u`, [51966]), [value("i32", 51966)]);
+
+// ./test/core/endianness64.wast:143
+assert_return(() => invoke($0, `i32_load`, [-1]), [value("i32", -1)]);
+
+// ./test/core/endianness64.wast:144
+assert_return(() => invoke($0, `i32_load`, [-42424242]), [value("i32", -42424242)]);
+
+// ./test/core/endianness64.wast:145
+assert_return(() => invoke($0, `i32_load`, [42424242]), [value("i32", 42424242)]);
+
+// ./test/core/endianness64.wast:146
+assert_return(() => invoke($0, `i32_load`, [-1414717974]), [value("i32", -1414717974)]);
+
+// ./test/core/endianness64.wast:148
+assert_return(() => invoke($0, `i64_load16_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness64.wast:149
+assert_return(() => invoke($0, `i64_load16_s`, [-4242n]), [value("i64", -4242n)]);
+
+// ./test/core/endianness64.wast:150
+assert_return(() => invoke($0, `i64_load16_s`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/endianness64.wast:151
+assert_return(() => invoke($0, `i64_load16_s`, [12816n]), [value("i64", 12816n)]);
+
+// ./test/core/endianness64.wast:153
+assert_return(() => invoke($0, `i64_load16_u`, [-1n]), [value("i64", 65535n)]);
+
+// ./test/core/endianness64.wast:154
+assert_return(() => invoke($0, `i64_load16_u`, [-4242n]), [value("i64", 61294n)]);
+
+// ./test/core/endianness64.wast:155
+assert_return(() => invoke($0, `i64_load16_u`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/endianness64.wast:156
+assert_return(() => invoke($0, `i64_load16_u`, [51966n]), [value("i64", 51966n)]);
+
+// ./test/core/endianness64.wast:158
+assert_return(() => invoke($0, `i64_load32_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness64.wast:159
+assert_return(() => invoke($0, `i64_load32_s`, [-42424242n]), [value("i64", -42424242n)]);
+
+// ./test/core/endianness64.wast:160
+assert_return(() => invoke($0, `i64_load32_s`, [42424242n]), [value("i64", 42424242n)]);
+
+// ./test/core/endianness64.wast:161
+assert_return(() => invoke($0, `i64_load32_s`, [305419896n]), [value("i64", 305419896n)]);
+
+// ./test/core/endianness64.wast:163
+assert_return(() => invoke($0, `i64_load32_u`, [-1n]), [value("i64", 4294967295n)]);
+
+// ./test/core/endianness64.wast:164
+assert_return(() => invoke($0, `i64_load32_u`, [-42424242n]), [value("i64", 4252543054n)]);
+
+// ./test/core/endianness64.wast:165
+assert_return(() => invoke($0, `i64_load32_u`, [42424242n]), [value("i64", 42424242n)]);
+
+// ./test/core/endianness64.wast:166
+assert_return(() => invoke($0, `i64_load32_u`, [2880249322n]), [value("i64", 2880249322n)]);
+
+// ./test/core/endianness64.wast:168
+assert_return(() => invoke($0, `i64_load`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness64.wast:169
+assert_return(() => invoke($0, `i64_load`, [-42424242n]), [value("i64", -42424242n)]);
+
+// ./test/core/endianness64.wast:170
+assert_return(() => invoke($0, `i64_load`, [2880249322n]), [value("i64", 2880249322n)]);
+
+// ./test/core/endianness64.wast:171
+assert_return(
+  () => invoke($0, `i64_load`, [-6075977126246539798n]),
+  [value("i64", -6075977126246539798n)],
+);
+
+// ./test/core/endianness64.wast:173
+assert_return(() => invoke($0, `f32_load`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/endianness64.wast:174
+assert_return(() => invoke($0, `f32_load`, [value("f32", 0.01234)]), [value("f32", 0.01234)]);
+
+// ./test/core/endianness64.wast:175
+assert_return(() => invoke($0, `f32_load`, [value("f32", 4242.4243)]), [value("f32", 4242.4243)]);
+
+// ./test/core/endianness64.wast:176
+assert_return(
+  () => invoke($0, `f32_load`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/endianness64.wast:178
+assert_return(() => invoke($0, `f64_load`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/endianness64.wast:179
+assert_return(() => invoke($0, `f64_load`, [value("f64", 1234.56789)]), [value("f64", 1234.56789)]);
+
+// ./test/core/endianness64.wast:180
+assert_return(
+  () => invoke($0, `f64_load`, [value("f64", 424242.424242)]),
+  [value("f64", 424242.424242)],
+);
+
+// ./test/core/endianness64.wast:181
+assert_return(
+  () => invoke($0, `f64_load`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/endianness64.wast:184
+assert_return(() => invoke($0, `i32_store16`, [-1]), [value("i32", 65535)]);
+
+// ./test/core/endianness64.wast:185
+assert_return(() => invoke($0, `i32_store16`, [-4242]), [value("i32", 61294)]);
+
+// ./test/core/endianness64.wast:186
+assert_return(() => invoke($0, `i32_store16`, [42]), [value("i32", 42)]);
+
+// ./test/core/endianness64.wast:187
+assert_return(() => invoke($0, `i32_store16`, [51966]), [value("i32", 51966)]);
+
+// ./test/core/endianness64.wast:189
+assert_return(() => invoke($0, `i32_store`, [-1]), [value("i32", -1)]);
+
+// ./test/core/endianness64.wast:190
+assert_return(() => invoke($0, `i32_store`, [-4242]), [value("i32", -4242)]);
+
+// ./test/core/endianness64.wast:191
+assert_return(() => invoke($0, `i32_store`, [42424242]), [value("i32", 42424242)]);
+
+// ./test/core/endianness64.wast:192
+assert_return(() => invoke($0, `i32_store`, [-559035650]), [value("i32", -559035650)]);
+
+// ./test/core/endianness64.wast:194
+assert_return(() => invoke($0, `i64_store16`, [-1n]), [value("i64", 65535n)]);
+
+// ./test/core/endianness64.wast:195
+assert_return(() => invoke($0, `i64_store16`, [-4242n]), [value("i64", 61294n)]);
+
+// ./test/core/endianness64.wast:196
+assert_return(() => invoke($0, `i64_store16`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/endianness64.wast:197
+assert_return(() => invoke($0, `i64_store16`, [51966n]), [value("i64", 51966n)]);
+
+// ./test/core/endianness64.wast:199
+assert_return(() => invoke($0, `i64_store32`, [-1n]), [value("i64", 4294967295n)]);
+
+// ./test/core/endianness64.wast:200
+assert_return(() => invoke($0, `i64_store32`, [-4242n]), [value("i64", 4294963054n)]);
+
+// ./test/core/endianness64.wast:201
+assert_return(() => invoke($0, `i64_store32`, [42424242n]), [value("i64", 42424242n)]);
+
+// ./test/core/endianness64.wast:202
+assert_return(() => invoke($0, `i64_store32`, [3735931646n]), [value("i64", 3735931646n)]);
+
+// ./test/core/endianness64.wast:204
+assert_return(() => invoke($0, `i64_store`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness64.wast:205
+assert_return(() => invoke($0, `i64_store`, [-42424242n]), [value("i64", -42424242n)]);
+
+// ./test/core/endianness64.wast:206
+assert_return(() => invoke($0, `i64_store`, [2880249322n]), [value("i64", 2880249322n)]);
+
+// ./test/core/endianness64.wast:207
+assert_return(
+  () => invoke($0, `i64_store`, [-6075977126246539798n]),
+  [value("i64", -6075977126246539798n)],
+);
+
+// ./test/core/endianness64.wast:209
+assert_return(() => invoke($0, `f32_store`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/endianness64.wast:210
+assert_return(() => invoke($0, `f32_store`, [value("f32", 0.01234)]), [value("f32", 0.01234)]);
+
+// ./test/core/endianness64.wast:211
+assert_return(() => invoke($0, `f32_store`, [value("f32", 4242.4243)]), [value("f32", 4242.4243)]);
+
+// ./test/core/endianness64.wast:212
+assert_return(
+  () => invoke($0, `f32_store`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/endianness64.wast:214
+assert_return(() => invoke($0, `f64_store`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/endianness64.wast:215
+assert_return(() => invoke($0, `f64_store`, [value("f64", 1234.56789)]), [value("f64", 1234.56789)]);
+
+// ./test/core/endianness64.wast:216
+assert_return(
+  () => invoke($0, `f64_store`, [value("f64", 424242.424242)]),
+  [value("f64", 424242.424242)],
+);
+
+// ./test/core/endianness64.wast:217
+assert_return(
+  () => invoke($0, `f64_store`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/float_memory64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/float_memory64.wast.js
new file mode 100644
index 0000000000..70f5605577
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/float_memory64.wast.js
@@ -0,0 +1,361 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/float_memory64.wast
+
+// ./test/core/float_memory64.wast:5
+let $0 = instantiate(`(module
+  (memory i64 (data "\\00\\00\\a0\\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i64.const 0)))
+  (func (export "i32.load") (result i32) (i32.load (i64.const 0)))
+  (func (export "f32.store") (f32.store (i64.const 0) (f32.const nan:0x200000)))
+  (func (export "i32.store") (i32.store (i64.const 0) (i32.const 0x7fa00000)))
+  (func (export "reset") (i32.store (i64.const 0) (i32.const 0)))
+)`);
+
+// ./test/core/float_memory64.wast:15
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory64.wast:16
+assert_return(() => invoke($0, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:17
+invoke($0, `reset`, []);
+
+// ./test/core/float_memory64.wast:18
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory64.wast:19
+assert_return(() => invoke($0, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory64.wast:20
+invoke($0, `f32.store`, []);
+
+// ./test/core/float_memory64.wast:21
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory64.wast:22
+assert_return(() => invoke($0, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:23
+invoke($0, `reset`, []);
+
+// ./test/core/float_memory64.wast:24
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory64.wast:25
+assert_return(() => invoke($0, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory64.wast:26
+invoke($0, `i32.store`, []);
+
+// ./test/core/float_memory64.wast:27
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory64.wast:28
+assert_return(() => invoke($0, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:30
+let $1 = instantiate(`(module
+  (memory i64 (data "\\00\\00\\00\\00\\00\\00\\f4\\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i64.const 0)))
+  (func (export "i64.load") (result i64) (i64.load (i64.const 0)))
+  (func (export "f64.store") (f64.store (i64.const 0) (f64.const nan:0x4000000000000)))
+  (func (export "i64.store") (i64.store (i64.const 0) (i64.const 0x7ff4000000000000)))
+  (func (export "reset") (i64.store (i64.const 0) (i64.const 0)))
+)`);
+
+// ./test/core/float_memory64.wast:40
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory64.wast:41
+assert_return(
+  () => invoke($1, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:42
+invoke($1, `reset`, []);
+
+// ./test/core/float_memory64.wast:43
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory64.wast:44
+assert_return(() => invoke($1, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory64.wast:45
+invoke($1, `f64.store`, []);
+
+// ./test/core/float_memory64.wast:46
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory64.wast:47
+assert_return(
+  () => invoke($1, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:48
+invoke($1, `reset`, []);
+
+// ./test/core/float_memory64.wast:49
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory64.wast:50
+assert_return(() => invoke($1, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory64.wast:51
+invoke($1, `i64.store`, []);
+
+// ./test/core/float_memory64.wast:52
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory64.wast:53
+assert_return(
+  () => invoke($1, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:57
+let $2 = instantiate(`(module
+  (memory i64 (data "\\00\\00\\00\\a0\\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i64.const 1)))
+  (func (export "i32.load") (result i32) (i32.load (i64.const 1)))
+  (func (export "f32.store") (f32.store (i64.const 1) (f32.const nan:0x200000)))
+  (func (export "i32.store") (i32.store (i64.const 1) (i32.const 0x7fa00000)))
+  (func (export "reset") (i32.store (i64.const 1) (i32.const 0)))
+)`);
+
+// ./test/core/float_memory64.wast:67
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory64.wast:68
+assert_return(() => invoke($2, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:69
+invoke($2, `reset`, []);
+
+// ./test/core/float_memory64.wast:70
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory64.wast:71
+assert_return(() => invoke($2, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory64.wast:72
+invoke($2, `f32.store`, []);
+
+// ./test/core/float_memory64.wast:73
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory64.wast:74
+assert_return(() => invoke($2, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:75
+invoke($2, `reset`, []);
+
+// ./test/core/float_memory64.wast:76
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory64.wast:77
+assert_return(() => invoke($2, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory64.wast:78
+invoke($2, `i32.store`, []);
+
+// ./test/core/float_memory64.wast:79
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory64.wast:80
+assert_return(() => invoke($2, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:82
+let $3 = instantiate(`(module
+  (memory i64 (data "\\00\\00\\00\\00\\00\\00\\00\\f4\\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i64.const 1)))
+  (func (export "i64.load") (result i64) (i64.load (i64.const 1)))
+  (func (export "f64.store") (f64.store (i64.const 1) (f64.const nan:0x4000000000000)))
+  (func (export "i64.store") (i64.store (i64.const 1) (i64.const 0x7ff4000000000000)))
+  (func (export "reset") (i64.store (i64.const 1) (i64.const 0)))
+)`);
+
+// ./test/core/float_memory64.wast:92
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory64.wast:93
+assert_return(
+  () => invoke($3, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:94
+invoke($3, `reset`, []);
+
+// ./test/core/float_memory64.wast:95
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory64.wast:96
+assert_return(() => invoke($3, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory64.wast:97
+invoke($3, `f64.store`, []);
+
+// ./test/core/float_memory64.wast:98
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory64.wast:99
+assert_return(
+  () => invoke($3, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:100
+invoke($3, `reset`, []);
+
+// ./test/core/float_memory64.wast:101
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory64.wast:102
+assert_return(() => invoke($3, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory64.wast:103
+invoke($3, `i64.store`, []);
+
+// ./test/core/float_memory64.wast:104
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory64.wast:105
+assert_return(
+  () => invoke($3, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:109
+let $4 = instantiate(`(module
+  (memory i64 (data "\\01\\00\\d0\\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i64.const 0)))
+  (func (export "i32.load") (result i32) (i32.load (i64.const 0)))
+  (func (export "f32.store") (f32.store (i64.const 0) (f32.const nan:0x500001)))
+  (func (export "i32.store") (i32.store (i64.const 0) (i32.const 0x7fd00001)))
+  (func (export "reset") (i32.store (i64.const 0) (i32.const 0)))
+)`);
+
+// ./test/core/float_memory64.wast:119
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 2144337921)]);
+
+// ./test/core/float_memory64.wast:120
+assert_return(() => invoke($4, `f32.load`, []), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:121
+invoke($4, `reset`, []);
+
+// ./test/core/float_memory64.wast:122
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory64.wast:123
+assert_return(() => invoke($4, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory64.wast:124
+invoke($4, `f32.store`, []);
+
+// ./test/core/float_memory64.wast:125
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 2144337921)]);
+
+// ./test/core/float_memory64.wast:126
+assert_return(() => invoke($4, `f32.load`, []), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:127
+invoke($4, `reset`, []);
+
+// ./test/core/float_memory64.wast:128
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory64.wast:129
+assert_return(() => invoke($4, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory64.wast:130
+invoke($4, `i32.store`, []);
+
+// ./test/core/float_memory64.wast:131
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 2144337921)]);
+
+// ./test/core/float_memory64.wast:132
+assert_return(() => invoke($4, `f32.load`, []), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/float_memory64.wast:134
+let $5 = instantiate(`(module
+  (memory i64 (data "\\01\\00\\00\\00\\00\\00\\fc\\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i64.const 0)))
+  (func (export "i64.load") (result i64) (i64.load (i64.const 0)))
+  (func (export "f64.store") (f64.store (i64.const 0) (f64.const nan:0xc000000000001)))
+  (func (export "i64.store") (i64.store (i64.const 0) (i64.const 0x7ffc000000000001)))
+  (func (export "reset") (i64.store (i64.const 0) (i64.const 0)))
+)`);
+
+// ./test/core/float_memory64.wast:144
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 9222246136947933185n)]);
+
+// ./test/core/float_memory64.wast:145
+assert_return(
+  () => invoke($5, `f64.load`, []),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:146
+invoke($5, `reset`, []);
+
+// ./test/core/float_memory64.wast:147
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory64.wast:148
+assert_return(() => invoke($5, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory64.wast:149
+invoke($5, `f64.store`, []);
+
+// ./test/core/float_memory64.wast:150
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 9222246136947933185n)]);
+
+// ./test/core/float_memory64.wast:151
+assert_return(
+  () => invoke($5, `f64.load`, []),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
+
+// ./test/core/float_memory64.wast:152
+invoke($5, `reset`, []);
+
+// ./test/core/float_memory64.wast:153
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory64.wast:154
+assert_return(() => invoke($5, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory64.wast:155
+invoke($5, `i64.store`, []);
+
+// ./test/core/float_memory64.wast:156
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 9222246136947933185n)]);
+
+// ./test/core/float_memory64.wast:157
+assert_return(
+  () => invoke($5, `f64.load`, []),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/memory64/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js b/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js
new file mode 100644
index 0000000000..a1a18d4b58
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/harness/harness.js
@@ -0,0 +1,371 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function partialOobWriteMayWritePartialData() {
+    let cfg = getBuildConfiguration();
+    let arm_native = cfg["arm"] && !cfg["arm-simulator"];
+    let arm64_native = cfg["arm64"] && !cfg["arm64-simulator"];
+    return arm_native || arm64_native;
+}
+
+let cfg = getBuildConfiguration();
+let native_arm = cfg["arm"] && !cfg["arm-simulator"];
+let native_arm64 = cfg["arm64"] && !cfg["arm64-simulator"];
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: 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",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/load64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/load64.wast.js
new file mode 100644
index 0000000000..c353960337
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/load64.wast.js
@@ -0,0 +1,749 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/load64.wast
+
+// ./test/core/load64.wast:3
+let $0 = instantiate(`(module
+  (memory i64 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i64.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (i32.load (i64.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.load (i64.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (i32.load (i64.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (i32.load (i64.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i32.load (i64.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (i32.load (i64.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (i32.load (i64.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (i32.load (i64.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.load (i64.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (i32.load (i64.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (i32.load (i64.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (i32.load (i64.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (i32.load (i64.const 0)))
+  )
+
+  (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $$f (i32.load (i64.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $$f (i32.const 1) (i32.load (i64.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $$f (i32.const 1) (i32.const 2) (i32.load (i64.const 0)))
+  )
+
+  (type $$sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $$sig)
+      (i32.load (i64.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.load (i64.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (i32.load (i64.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (i32.load (i64.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (i32.load (i64.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (i32.load (i64.const 0)))
+  )
+  (global $$g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $$g (i32.load (i64.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (i64.load (i64.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (i64.load (i64.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (i64.load (i64.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i64.const 2) (i32.load (i64.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (i64.load8_s (i64.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i64.const 2) (i32.load (i64.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (i32.load (i64.const 100)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (i32.load (i64.const 100)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (i32.load (i64.const 100)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (i32.load (i64.const 100)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (i32.load (i64.const 100)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (i32.load (i64.const 100)))
+  )
+
+  (func (export "as-memory.grow-size") (result i64)
+    (memory.grow (i64.load (i64.const 100)))
+  )
+)`);
+
+// ./test/core/load64.wast:161
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:163
+assert_return(() => invoke($0, `as-br_if-cond`, []), []);
+
+// ./test/core/load64.wast:164
+assert_return(() => invoke($0, `as-br_if-value`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:165
+assert_return(() => invoke($0, `as-br_if-value-cond`, []), [value("i32", 7)]);
+
+// ./test/core/load64.wast:167
+assert_return(() => invoke($0, `as-br_table-index`, []), []);
+
+// ./test/core/load64.wast:168
+assert_return(() => invoke($0, `as-br_table-value`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:169
+assert_return(() => invoke($0, `as-br_table-value-index`, []), [value("i32", 6)]);
+
+// ./test/core/load64.wast:171
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:173
+assert_return(() => invoke($0, `as-if-cond`, []), [value("i32", 1)]);
+
+// ./test/core/load64.wast:174
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:175
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:177
+assert_return(() => invoke($0, `as-select-first`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/load64.wast:178
+assert_return(() => invoke($0, `as-select-second`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/load64.wast:179
+assert_return(() => invoke($0, `as-select-cond`, []), [value("i32", 1)]);
+
+// ./test/core/load64.wast:181
+assert_return(() => invoke($0, `as-call-first`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:182
+assert_return(() => invoke($0, `as-call-mid`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:183
+assert_return(() => invoke($0, `as-call-last`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:185
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:186
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:187
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:188
+assert_return(() => invoke($0, `as-call_indirect-index`, []), [value("i32", -1)]);
+
+// ./test/core/load64.wast:190
+assert_return(() => invoke($0, `as-local.set-value`, []), []);
+
+// ./test/core/load64.wast:191
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:192
+assert_return(() => invoke($0, `as-global.set-value`, []), []);
+
+// ./test/core/load64.wast:194
+assert_return(() => invoke($0, `as-load-address`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:195
+assert_return(() => invoke($0, `as-loadN-address`, []), [value("i32", 0)]);
+
+// ./test/core/load64.wast:196
+assert_return(() => invoke($0, `as-store-address`, []), []);
+
+// ./test/core/load64.wast:197
+assert_return(() => invoke($0, `as-store-value`, []), []);
+
+// ./test/core/load64.wast:198
+assert_return(() => invoke($0, `as-storeN-address`, []), []);
+
+// ./test/core/load64.wast:199
+assert_return(() => invoke($0, `as-storeN-value`, []), []);
+
+// ./test/core/load64.wast:201
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 32)]);
+
+// ./test/core/load64.wast:203
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 10)]);
+
+// ./test/core/load64.wast:204
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 10)]);
+
+// ./test/core/load64.wast:206
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 1)]);
+
+// ./test/core/load64.wast:208
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/load64.wast:209
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/load64.wast:211
+assert_return(() => invoke($0, `as-memory.grow-size`, []), [value("i64", 1n)]);
+
+// ./test/core/load64.wast:213
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i32) (i32.load32 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:220
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i32) (i32.load32_u (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:227
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i32) (i32.load32_s (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:234
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i32) (i32.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:241
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i32) (i32.load64_u (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:248
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i32) (i32.load64_s (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:256
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i64) (i64.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:263
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i64) (i64.load64_u (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:270
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result i64) (i64.load64_s (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:278
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result f32) (f32.load32 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:285
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result f32) (f32.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:293
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result f64) (f64.load32 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:300
+assert_malformed(
+  () => instantiate(`(memory i64 1) (func (param i64) (result f64) (f64.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load64.wast:311
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load_i32 (i32.load (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:315
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load8_s_i32 (i32.load8_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:319
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load8_u_i32 (i32.load8_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:323
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load16_s_i32 (i32.load16_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:327
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load16_u_i32 (i32.load16_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:331
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load_i64 (i64.load (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:335
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load8_s_i64 (i64.load8_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:339
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load8_u_i64 (i64.load8_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:343
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load16_s_i64 (i64.load16_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:347
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load16_u_i64 (i64.load16_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:351
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load32_s_i64 (i64.load32_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:355
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load32_u_i64 (i64.load32_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:359
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load_f32 (f32.load (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:363
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func $$load_f64 (f64.load (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:371
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i32) (i32.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:372
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i32) (i32.load8_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:373
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i32) (i32.load8_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:374
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i32) (i32.load16_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:375
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i32) (i32.load16_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:376
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:377
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load8_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:378
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load8_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:379
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load16_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:380
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load16_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:381
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load32_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:382
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result i64) (i64.load32_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:383
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result f32) (f32.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:384
+assert_invalid(
+  () => instantiate(`(module (memory i64 1) (func (result f64) (f64.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:387
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty
+      (i32.load) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:396
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-block
+      (i32.const 0)
+      (block (i32.load) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:406
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-loop
+      (i32.const 0)
+      (loop (i32.load) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:416
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.load) (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:426
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.load))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:436
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.load)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:446
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.load) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:456
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.load)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:466
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-return
+      (return (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:475
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-select
+      (select (i32.load) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:484
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-call
+      (call 1 (i32.load)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:494
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-address-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.load) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:511
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.load)) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:521
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:531
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-address-empty-in-global.set
+      (global.set $$x (i32.load)) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:541
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-memory.grow
+      (memory.grow (i64.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:550
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 0)
+    (func $$type-address-empty-in-load
+      (i32.load (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load64.wast:559
+assert_invalid(
+  () => instantiate(`(module
+    (memory i64 1)
+    (func $$type-address-empty-in-store
+      (i32.store (i32.load) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/memory64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/memory64.wast.js
new file mode 100644
index 0000000000..341742ab86
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/memory64.wast.js
@@ -0,0 +1,324 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory64.wast
+
+// ./test/core/memory64.wast:3
+let $0 = instantiate(`(module (memory i64 0 0))`);
+
+// ./test/core/memory64.wast:4
+let $1 = instantiate(`(module (memory i64 0 1))`);
+
+// ./test/core/memory64.wast:5
+let $2 = instantiate(`(module (memory i64 1 256))`);
+
+// ./test/core/memory64.wast:6
+let $3 = instantiate(`(module (memory i64 0 65536))`);
+
+// ./test/core/memory64.wast:8
+assert_invalid(
+  () => instantiate(`(module (memory i64 0) (memory i64 0))`),
+  `multiple memories`,
+);
+
+// ./test/core/memory64.wast:9
+assert_invalid(
+  () => instantiate(`(module (memory (import "spectest" "memory") i64 0) (memory i64 0))`),
+  `multiple memories`,
+);
+
+// ./test/core/memory64.wast:11
+let $4 = instantiate(`(module (memory i64 (data)) (func (export "memsize") (result i64) (memory.size)))`);
+
+// ./test/core/memory64.wast:12
+assert_return(() => invoke($4, `memsize`, []), [value("i64", 0n)]);
+
+// ./test/core/memory64.wast:13
+let $5 = instantiate(`(module (memory i64 (data "")) (func (export "memsize") (result i64) (memory.size)))`);
+
+// ./test/core/memory64.wast:14
+assert_return(() => invoke($5, `memsize`, []), [value("i64", 0n)]);
+
+// ./test/core/memory64.wast:15
+let $6 = instantiate(`(module (memory i64 (data "x")) (func (export "memsize") (result i64) (memory.size)))`);
+
+// ./test/core/memory64.wast:16
+assert_return(() => invoke($6, `memsize`, []), [value("i64", 1n)]);
+
+// ./test/core/memory64.wast:18
+assert_invalid(() => instantiate(`(module (data (i64.const 0)))`), `unknown memory`);
+
+// ./test/core/memory64.wast:19
+assert_invalid(() => instantiate(`(module (data (i64.const 0) ""))`), `unknown memory`);
+
+// ./test/core/memory64.wast:20
+assert_invalid(() => instantiate(`(module (data (i64.const 0) "x"))`), `unknown memory`);
+
+// ./test/core/memory64.wast:22
+assert_invalid(
+  () => instantiate(`(module (func (drop (f32.load (i64.const 0)))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory64.wast:26
+assert_invalid(
+  () => instantiate(`(module (func (f32.store (i64.const 0) (f32.const 0))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory64.wast:30
+assert_invalid(
+  () => instantiate(`(module (func (drop (i32.load8_s (i64.const 0)))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory64.wast:34
+assert_invalid(
+  () => instantiate(`(module (func (i32.store8 (i64.const 0) (i32.const 0))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory64.wast:38
+assert_invalid(
+  () => instantiate(`(module (func (drop (memory.size))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory64.wast:42
+assert_invalid(
+  () => instantiate(`(module (func (drop (memory.grow (i64.const 0)))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory64.wast:48
+assert_invalid(
+  () => instantiate(`(module (memory i64 1 0))`),
+  `size minimum must not be greater than maximum`,
+);
+
+// ./test/core/memory64.wast:53
+let $7 = instantiate(`(module
+  (memory i64 1)
+  (data (i64.const 0) "ABC\\a7D") (data (i64.const 20) "WASM")
+
+  ;; Data section
+  (func (export "data") (result i32)
+    (i32.and
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i64.const 0)) (i32.const 65))
+          (i32.eq (i32.load8_u (i64.const 3)) (i32.const 167))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i64.const 6)) (i32.const 0))
+          (i32.eq (i32.load8_u (i64.const 19)) (i32.const 0))
+        )
+      )
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i64.const 20)) (i32.const 87))
+          (i32.eq (i32.load8_u (i64.const 23)) (i32.const 77))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i64.const 24)) (i32.const 0))
+          (i32.eq (i32.load8_u (i64.const 1023)) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  ;; Memory cast
+  (func (export "cast") (result f64)
+    (i64.store (i64.const 8) (i64.const -12345))
+    (if
+      (f64.eq
+        (f64.load (i64.const 8))
+        (f64.reinterpret_i64 (i64.const -12345))
+      )
+      (then (return (f64.const 0)))
+    )
+    (i64.store align=1 (i64.const 9) (i64.const 0))
+    (i32.store16 align=1 (i64.const 15) (i32.const 16453))
+    (f64.load align=1 (i64.const 9))
+  )
+
+  ;; Sign and zero extending memory loads
+  (func (export "i32_load8_s") (param $$i i32) (result i32)
+	(i32.store8 (i64.const 8) (local.get $$i))
+	(i32.load8_s (i64.const 8))
+  )
+  (func (export "i32_load8_u") (param $$i i32) (result i32)
+	(i32.store8 (i64.const 8) (local.get $$i))
+	(i32.load8_u (i64.const 8))
+  )
+  (func (export "i32_load16_s") (param $$i i32) (result i32)
+	(i32.store16 (i64.const 8) (local.get $$i))
+	(i32.load16_s (i64.const 8))
+  )
+  (func (export "i32_load16_u") (param $$i i32) (result i32)
+	(i32.store16 (i64.const 8) (local.get $$i))
+	(i32.load16_u (i64.const 8))
+  )
+  (func (export "i64_load8_s") (param $$i i64) (result i64)
+	(i64.store8 (i64.const 8) (local.get $$i))
+	(i64.load8_s (i64.const 8))
+  )
+  (func (export "i64_load8_u") (param $$i i64) (result i64)
+	(i64.store8 (i64.const 8) (local.get $$i))
+	(i64.load8_u (i64.const 8))
+  )
+  (func (export "i64_load16_s") (param $$i i64) (result i64)
+	(i64.store16 (i64.const 8) (local.get $$i))
+	(i64.load16_s (i64.const 8))
+  )
+  (func (export "i64_load16_u") (param $$i i64) (result i64)
+	(i64.store16 (i64.const 8) (local.get $$i))
+	(i64.load16_u (i64.const 8))
+  )
+  (func (export "i64_load32_s") (param $$i i64) (result i64)
+	(i64.store32 (i64.const 8) (local.get $$i))
+	(i64.load32_s (i64.const 8))
+  )
+  (func (export "i64_load32_u") (param $$i i64) (result i64)
+	(i64.store32 (i64.const 8) (local.get $$i))
+	(i64.load32_u (i64.const 8))
+  )
+)`);
+
+// ./test/core/memory64.wast:141
+assert_return(() => invoke($7, `data`, []), [value("i32", 1)]);
+
+// ./test/core/memory64.wast:142
+assert_return(() => invoke($7, `cast`, []), [value("f64", 42)]);
+
+// ./test/core/memory64.wast:144
+assert_return(() => invoke($7, `i32_load8_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/memory64.wast:145
+assert_return(() => invoke($7, `i32_load8_u`, [-1]), [value("i32", 255)]);
+
+// ./test/core/memory64.wast:146
+assert_return(() => invoke($7, `i32_load16_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/memory64.wast:147
+assert_return(() => invoke($7, `i32_load16_u`, [-1]), [value("i32", 65535)]);
+
+// ./test/core/memory64.wast:149
+assert_return(() => invoke($7, `i32_load8_s`, [100]), [value("i32", 100)]);
+
+// ./test/core/memory64.wast:150
+assert_return(() => invoke($7, `i32_load8_u`, [200]), [value("i32", 200)]);
+
+// ./test/core/memory64.wast:151
+assert_return(() => invoke($7, `i32_load16_s`, [20000]), [value("i32", 20000)]);
+
+// ./test/core/memory64.wast:152
+assert_return(() => invoke($7, `i32_load16_u`, [40000]), [value("i32", 40000)]);
+
+// ./test/core/memory64.wast:154
+assert_return(() => invoke($7, `i32_load8_s`, [-19110589]), [value("i32", 67)]);
+
+// ./test/core/memory64.wast:155
+assert_return(() => invoke($7, `i32_load8_s`, [878104047]), [value("i32", -17)]);
+
+// ./test/core/memory64.wast:156
+assert_return(() => invoke($7, `i32_load8_u`, [-19110589]), [value("i32", 67)]);
+
+// ./test/core/memory64.wast:157
+assert_return(() => invoke($7, `i32_load8_u`, [878104047]), [value("i32", 239)]);
+
+// ./test/core/memory64.wast:158
+assert_return(() => invoke($7, `i32_load16_s`, [-19110589]), [value("i32", 25923)]);
+
+// ./test/core/memory64.wast:159
+assert_return(() => invoke($7, `i32_load16_s`, [878104047]), [value("i32", -12817)]);
+
+// ./test/core/memory64.wast:160
+assert_return(() => invoke($7, `i32_load16_u`, [-19110589]), [value("i32", 25923)]);
+
+// ./test/core/memory64.wast:161
+assert_return(() => invoke($7, `i32_load16_u`, [878104047]), [value("i32", 52719)]);
+
+// ./test/core/memory64.wast:163
+assert_return(() => invoke($7, `i64_load8_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/memory64.wast:164
+assert_return(() => invoke($7, `i64_load8_u`, [-1n]), [value("i64", 255n)]);
+
+// ./test/core/memory64.wast:165
+assert_return(() => invoke($7, `i64_load16_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/memory64.wast:166
+assert_return(() => invoke($7, `i64_load16_u`, [-1n]), [value("i64", 65535n)]);
+
+// ./test/core/memory64.wast:167
+assert_return(() => invoke($7, `i64_load32_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/memory64.wast:168
+assert_return(() => invoke($7, `i64_load32_u`, [-1n]), [value("i64", 4294967295n)]);
+
+// ./test/core/memory64.wast:170
+assert_return(() => invoke($7, `i64_load8_s`, [100n]), [value("i64", 100n)]);
+
+// ./test/core/memory64.wast:171
+assert_return(() => invoke($7, `i64_load8_u`, [200n]), [value("i64", 200n)]);
+
+// ./test/core/memory64.wast:172
+assert_return(() => invoke($7, `i64_load16_s`, [20000n]), [value("i64", 20000n)]);
+
+// ./test/core/memory64.wast:173
+assert_return(() => invoke($7, `i64_load16_u`, [40000n]), [value("i64", 40000n)]);
+
+// ./test/core/memory64.wast:174
+assert_return(() => invoke($7, `i64_load32_s`, [20000n]), [value("i64", 20000n)]);
+
+// ./test/core/memory64.wast:175
+assert_return(() => invoke($7, `i64_load32_u`, [40000n]), [value("i64", 40000n)]);
+
+// ./test/core/memory64.wast:177
+assert_return(() => invoke($7, `i64_load8_s`, [-81985529755441853n]), [value("i64", 67n)]);
+
+// ./test/core/memory64.wast:178
+assert_return(() => invoke($7, `i64_load8_s`, [3771275841602506223n]), [value("i64", -17n)]);
+
+// ./test/core/memory64.wast:179
+assert_return(() => invoke($7, `i64_load8_u`, [-81985529755441853n]), [value("i64", 67n)]);
+
+// ./test/core/memory64.wast:180
+assert_return(() => invoke($7, `i64_load8_u`, [3771275841602506223n]), [value("i64", 239n)]);
+
+// ./test/core/memory64.wast:181
+assert_return(() => invoke($7, `i64_load16_s`, [-81985529755441853n]), [value("i64", 25923n)]);
+
+// ./test/core/memory64.wast:182
+assert_return(() => invoke($7, `i64_load16_s`, [3771275841602506223n]), [value("i64", -12817n)]);
+
+// ./test/core/memory64.wast:183
+assert_return(() => invoke($7, `i64_load16_u`, [-81985529755441853n]), [value("i64", 25923n)]);
+
+// ./test/core/memory64.wast:184
+assert_return(() => invoke($7, `i64_load16_u`, [3771275841602506223n]), [value("i64", 52719n)]);
+
+// ./test/core/memory64.wast:185
+assert_return(() => invoke($7, `i64_load32_s`, [-81985529755441853n]), [value("i64", 1446274371n)]);
+
+// ./test/core/memory64.wast:186
+assert_return(() => invoke($7, `i64_load32_s`, [3771275841602506223n]), [value("i64", -1732588049n)]);
+
+// ./test/core/memory64.wast:187
+assert_return(() => invoke($7, `i64_load32_u`, [-81985529755441853n]), [value("i64", 1446274371n)]);
+
+// ./test/core/memory64.wast:188
+assert_return(() => invoke($7, `i64_load32_u`, [3771275841602506223n]), [value("i64", 2562379247n)]);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/memory_grow64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/memory_grow64.wast.js
new file mode 100644
index 0000000000..5286d975d8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/memory_grow64.wast.js
@@ -0,0 +1,199 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_grow64.wast
+
+// ./test/core/memory_grow64.wast:1
+let $0 = instantiate(`(module
+    (memory i64 0)
+
+    (func (export "load_at_zero") (result i32) (i32.load (i64.const 0)))
+    (func (export "store_at_zero") (i32.store (i64.const 0) (i32.const 2)))
+
+    (func (export "load_at_page_size") (result i32) (i32.load (i64.const 0x10000)))
+    (func (export "store_at_page_size") (i32.store (i64.const 0x10000) (i32.const 3)))
+
+    (func (export "grow") (param $$sz i64) (result i64) (memory.grow (local.get $$sz)))
+    (func (export "size") (result i64) (memory.size))
+)`);
+
+// ./test/core/memory_grow64.wast:14
+assert_return(() => invoke($0, `size`, []), [value("i64", 0n)]);
+
+// ./test/core/memory_grow64.wast:15
+assert_trap(() => invoke($0, `store_at_zero`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow64.wast:16
+assert_trap(() => invoke($0, `load_at_zero`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow64.wast:17
+assert_trap(() => invoke($0, `store_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow64.wast:18
+assert_trap(() => invoke($0, `load_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow64.wast:19
+assert_return(() => invoke($0, `grow`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/memory_grow64.wast:20
+assert_return(() => invoke($0, `size`, []), [value("i64", 1n)]);
+
+// ./test/core/memory_grow64.wast:21
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:22
+assert_return(() => invoke($0, `store_at_zero`, []), []);
+
+// ./test/core/memory_grow64.wast:23
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 2)]);
+
+// ./test/core/memory_grow64.wast:24
+assert_trap(() => invoke($0, `store_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow64.wast:25
+assert_trap(() => invoke($0, `load_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow64.wast:26
+assert_return(() => invoke($0, `grow`, [4n]), [value("i64", 1n)]);
+
+// ./test/core/memory_grow64.wast:27
+assert_return(() => invoke($0, `size`, []), [value("i64", 5n)]);
+
+// ./test/core/memory_grow64.wast:28
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 2)]);
+
+// ./test/core/memory_grow64.wast:29
+assert_return(() => invoke($0, `store_at_zero`, []), []);
+
+// ./test/core/memory_grow64.wast:30
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 2)]);
+
+// ./test/core/memory_grow64.wast:31
+assert_return(() => invoke($0, `load_at_page_size`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:32
+assert_return(() => invoke($0, `store_at_page_size`, []), []);
+
+// ./test/core/memory_grow64.wast:33
+assert_return(() => invoke($0, `load_at_page_size`, []), [value("i32", 3)]);
+
+// ./test/core/memory_grow64.wast:36
+let $1 = instantiate(`(module
+  (memory i64 0)
+  (func (export "grow") (param i64) (result i64) (memory.grow (local.get 0)))
+)`);
+
+// ./test/core/memory_grow64.wast:41
+assert_return(() => invoke($1, `grow`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/memory_grow64.wast:42
+assert_return(() => invoke($1, `grow`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/memory_grow64.wast:43
+assert_return(() => invoke($1, `grow`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/memory_grow64.wast:44
+assert_return(() => invoke($1, `grow`, [2n]), [value("i64", 1n)]);
+
+// ./test/core/memory_grow64.wast:45
+assert_return(() => invoke($1, `grow`, [800n]), [value("i64", 3n)]);
+
+// ./test/core/memory_grow64.wast:46
+assert_return(() => invoke($1, `grow`, [1n]), [value("i64", 803n)]);
+
+// ./test/core/memory_grow64.wast:48
+let $2 = instantiate(`(module
+  (memory i64 0 10)
+  (func (export "grow") (param i64) (result i64) (memory.grow (local.get 0)))
+)`);
+
+// ./test/core/memory_grow64.wast:53
+assert_return(() => invoke($2, `grow`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/memory_grow64.wast:54
+assert_return(() => invoke($2, `grow`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/memory_grow64.wast:55
+assert_return(() => invoke($2, `grow`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/memory_grow64.wast:56
+assert_return(() => invoke($2, `grow`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/memory_grow64.wast:57
+assert_return(() => invoke($2, `grow`, [6n]), [value("i64", 4n)]);
+
+// ./test/core/memory_grow64.wast:58
+assert_return(() => invoke($2, `grow`, [0n]), [value("i64", 10n)]);
+
+// ./test/core/memory_grow64.wast:59
+assert_return(() => invoke($2, `grow`, [1n]), [value("i64", -1n)]);
+
+// ./test/core/memory_grow64.wast:60
+assert_return(() => invoke($2, `grow`, [65536n]), [value("i64", -1n)]);
+
+// ./test/core/memory_grow64.wast:64
+let $3 = instantiate(`(module
+  (memory i64 1)
+  (func (export "grow") (param i64) (result i64)
+    (memory.grow (local.get 0))
+  )
+  (func (export "check-memory-zero") (param i64 i64) (result i32)
+    (local i32)
+    (local.set 2 (i32.const 1))
+    (block
+      (loop
+        (local.set 2 (i32.load8_u (local.get 0)))
+        (br_if 1 (i32.ne (local.get 2) (i32.const 0)))
+        (br_if 1 (i64.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i64.add (local.get 0) (i64.const 1)))
+        (br_if 0 (i64.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)`);
+
+// ./test/core/memory_grow64.wast:85
+assert_return(() => invoke($3, `check-memory-zero`, [0n, 65535n]), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:86
+assert_return(() => invoke($3, `grow`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/memory_grow64.wast:87
+assert_return(() => invoke($3, `check-memory-zero`, [65536n, 131071n]), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:88
+assert_return(() => invoke($3, `grow`, [1n]), [value("i64", 2n)]);
+
+// ./test/core/memory_grow64.wast:89
+assert_return(() => invoke($3, `check-memory-zero`, [131072n, 196607n]), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:90
+assert_return(() => invoke($3, `grow`, [1n]), [value("i64", 3n)]);
+
+// ./test/core/memory_grow64.wast:91
+assert_return(() => invoke($3, `check-memory-zero`, [196608n, 262143n]), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:92
+assert_return(() => invoke($3, `grow`, [1n]), [value("i64", 4n)]);
+
+// ./test/core/memory_grow64.wast:93
+assert_return(() => invoke($3, `check-memory-zero`, [262144n, 327679n]), [value("i32", 0)]);
+
+// ./test/core/memory_grow64.wast:94
+assert_return(() => invoke($3, `grow`, [1n]), [value("i64", 5n)]);
+
+// ./test/core/memory_grow64.wast:95
+assert_return(() => invoke($3, `check-memory-zero`, [327680n, 393215n]), [value("i32", 0)]);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/memory_redundancy64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/memory_redundancy64.wast.js
new file mode 100644
index 0000000000..5801c3057e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/memory_redundancy64.wast.js
@@ -0,0 +1,95 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_redundancy64.wast
+
+// ./test/core/memory_redundancy64.wast:5
+let $0 = instantiate(`(module
+  (memory i64 1 1)
+
+  (func (export "zero_everything")
+    (i32.store (i64.const 0) (i32.const 0))
+    (i32.store (i64.const 4) (i32.const 0))
+    (i32.store (i64.const 8) (i32.const 0))
+    (i32.store (i64.const 12) (i32.const 0))
+  )
+
+  (func (export "test_store_to_load") (result i32)
+    (i32.store (i64.const 8) (i32.const 0))
+    (f32.store (i64.const 5) (f32.const -0.0))
+    (i32.load (i64.const 8))
+  )
+
+  (func (export "test_redundant_load") (result i32)
+    (local $$t i32)
+    (local $$s i32)
+    (local.set $$t (i32.load (i64.const 8)))
+    (i32.store (i64.const 5) (i32.const 0x80000000))
+    (local.set $$s (i32.load (i64.const 8)))
+    (i32.add (local.get $$t) (local.get $$s))
+  )
+
+  (func (export "test_dead_store") (result f32)
+    (local $$t f32)
+    (i32.store (i64.const 8) (i32.const 0x23232323))
+    (local.set $$t (f32.load (i64.const 11)))
+    (i32.store (i64.const 8) (i32.const 0))
+    (local.get $$t)
+  )
+
+  ;; A function named "malloc" which implementations nonetheless shouldn't
+  ;; assume behaves like C malloc.
+  (func $$malloc (export "malloc")
+     (param $$size i64)
+     (result i64)
+     (i64.const 16)
+  )
+
+  ;; Call malloc twice, but unlike C malloc, we don't get non-aliasing pointers.
+  (func (export "malloc_aliasing")
+     (result i32)
+     (local $$x i64)
+     (local $$y i64)
+     (local.set $$x (call $$malloc (i64.const 4)))
+     (local.set $$y (call $$malloc (i64.const 4)))
+     (i32.store (local.get $$x) (i32.const 42))
+     (i32.store (local.get $$y) (i32.const 43))
+     (i32.load (local.get $$x))
+  )
+)`);
+
+// ./test/core/memory_redundancy64.wast:59
+assert_return(() => invoke($0, `test_store_to_load`, []), [value("i32", 128)]);
+
+// ./test/core/memory_redundancy64.wast:60
+invoke($0, `zero_everything`, []);
+
+// ./test/core/memory_redundancy64.wast:61
+assert_return(() => invoke($0, `test_redundant_load`, []), [value("i32", 128)]);
+
+// ./test/core/memory_redundancy64.wast:62
+invoke($0, `zero_everything`, []);
+
+// ./test/core/memory_redundancy64.wast:63
+assert_return(
+  () => invoke($0, `test_dead_store`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000049)],
+);
+
+// ./test/core/memory_redundancy64.wast:64
+invoke($0, `zero_everything`, []);
+
+// ./test/core/memory_redundancy64.wast:65
+assert_return(() => invoke($0, `malloc_aliasing`, []), [value("i32", 43)]);
diff --git a/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js b/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js
new file mode 100644
index 0000000000..ffc8eb2cb3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/memory64/memory_trap64.wast.js
@@ -0,0 +1,632 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_trap64.wast
+
+// ./test/core/memory_trap64.wast:1
+let $0 = instantiate(`(module
+    (memory i64 1)
+
+    (func $$addr_limit (result i64)
+      (i64.mul (memory.size) (i64.const 0x10000))
+    )
+
+    (func (export "store") (param $$i i64) (param $$v i32)
+      (i32.store (i64.add (call $$addr_limit) (local.get $$i)) (local.get $$v))
+    )
+
+    (func (export "load") (param $$i i64) (result i32)
+      (i32.load (i64.add (call $$addr_limit) (local.get $$i)))
+    )
+
+    (func (export "memory.grow") (param i64) (result i64)
+      (memory.grow (local.get 0))
+    )
+)`);
+
+// ./test/core/memory_trap64.wast:21
+assert_return(() => invoke($0, `store`, [-4n, 42]), []);
+
+// ./test/core/memory_trap64.wast:22
+assert_return(() => invoke($0, `load`, [-4n]), [value("i32", 42)]);
+
+// ./test/core/memory_trap64.wast:23
+assert_trap(() => invoke($0, `store`, [-3n, 13]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:24
+assert_trap(() => invoke($0, `load`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:25
+assert_trap(() => invoke($0, `store`, [-2n, 13]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:26
+assert_trap(() => invoke($0, `load`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:27
+assert_trap(() => invoke($0, `store`, [-1n, 13]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:28
+assert_trap(() => invoke($0, `load`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:29
+assert_trap(() => invoke($0, `store`, [0n, 13]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:30
+assert_trap(() => invoke($0, `load`, [0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:31
+assert_trap(() => invoke($0, `store`, [2147483648n, 13]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:32
+assert_trap(() => invoke($0, `load`, [2147483648n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:34
+let $1 = instantiate(`(module
+  (memory i64 1)
+  (data (i64.const 0) "abcdefgh")
+  (data (i64.const 0xfff8) "abcdefgh")
+
+  (func (export "i32.load") (param $$a i64) (result i32)
+    (i32.load (local.get $$a))
+  )
+  (func (export "i64.load") (param $$a i64) (result i64)
+    (i64.load (local.get $$a))
+  )
+  (func (export "f32.load") (param $$a i64) (result f32)
+    (f32.load (local.get $$a))
+  )
+  (func (export "f64.load") (param $$a i64) (result f64)
+    (f64.load (local.get $$a))
+  )
+  (func (export "i32.load8_s") (param $$a i64) (result i32)
+    (i32.load8_s (local.get $$a))
+  )
+  (func (export "i32.load8_u") (param $$a i64) (result i32)
+    (i32.load8_u (local.get $$a))
+  )
+  (func (export "i32.load16_s") (param $$a i64) (result i32)
+    (i32.load16_s (local.get $$a))
+  )
+  (func (export "i32.load16_u") (param $$a i64) (result i32)
+    (i32.load16_u (local.get $$a))
+  )
+  (func (export "i64.load8_s") (param $$a i64) (result i64)
+    (i64.load8_s (local.get $$a))
+  )
+  (func (export "i64.load8_u") (param $$a i64) (result i64)
+    (i64.load8_u (local.get $$a))
+  )
+  (func (export "i64.load16_s") (param $$a i64) (result i64)
+    (i64.load16_s (local.get $$a))
+  )
+  (func (export "i64.load16_u") (param $$a i64) (result i64)
+    (i64.load16_u (local.get $$a))
+  )
+  (func (export "i64.load32_s") (param $$a i64) (result i64)
+    (i64.load32_s (local.get $$a))
+  )
+  (func (export "i64.load32_u") (param $$a i64) (result i64)
+    (i64.load32_u (local.get $$a))
+  )
+  (func (export "i32.store") (param $$a i64) (param $$v i32)
+    (i32.store (local.get $$a) (local.get $$v))
+  )
+  (func (export "i64.store") (param $$a i64) (param $$v i64)
+    (i64.store (local.get $$a) (local.get $$v))
+  )
+  (func (export "f32.store") (param $$a i64) (param $$v f32)
+    (f32.store (local.get $$a) (local.get $$v))
+  )
+  (func (export "f64.store") (param $$a i64) (param $$v f64)
+    (f64.store (local.get $$a) (local.get $$v))
+  )
+  (func (export "i32.store8") (param $$a i64) (param $$v i32)
+    (i32.store8 (local.get $$a) (local.get $$v))
+  )
+  (func (export "i32.store16") (param $$a i64) (param $$v i32)
+    (i32.store16 (local.get $$a) (local.get $$v))
+  )
+  (func (export "i64.store8") (param $$a i64) (param $$v i64)
+    (i64.store8 (local.get $$a) (local.get $$v))
+  )
+  (func (export "i64.store16") (param $$a i64) (param $$v i64)
+    (i64.store16 (local.get $$a) (local.get $$v))
+  )
+  (func (export "i64.store32") (param $$a i64) (param $$v i64)
+    (i64.store32 (local.get $$a) (local.get $$v))
+  )
+)`);
+
+// ./test/core/memory_trap64.wast:110
+assert_trap(() => invoke($1, `i32.store`, [65536n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:111
+assert_trap(() => invoke($1, `i32.store`, [65535n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:112
+assert_trap(() => invoke($1, `i32.store`, [65534n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:113
+assert_trap(() => invoke($1, `i32.store`, [65533n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:114
+assert_trap(() => invoke($1, `i32.store`, [-1n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:115
+assert_trap(() => invoke($1, `i32.store`, [-2n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:116
+assert_trap(() => invoke($1, `i32.store`, [-3n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:117
+assert_trap(() => invoke($1, `i32.store`, [-4n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:118
+assert_trap(() => invoke($1, `i64.store`, [65536n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:119
+assert_trap(() => invoke($1, `i64.store`, [65535n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:120
+assert_trap(() => invoke($1, `i64.store`, [65534n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:121
+assert_trap(() => invoke($1, `i64.store`, [65533n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:122
+assert_trap(() => invoke($1, `i64.store`, [65532n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:123
+assert_trap(() => invoke($1, `i64.store`, [65531n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:124
+assert_trap(() => invoke($1, `i64.store`, [65530n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:125
+assert_trap(() => invoke($1, `i64.store`, [65529n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:126
+assert_trap(() => invoke($1, `i64.store`, [-1n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:127
+assert_trap(() => invoke($1, `i64.store`, [-2n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:128
+assert_trap(() => invoke($1, `i64.store`, [-3n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:129
+assert_trap(() => invoke($1, `i64.store`, [-4n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:130
+assert_trap(() => invoke($1, `i64.store`, [-5n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:131
+assert_trap(() => invoke($1, `i64.store`, [-6n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:132
+assert_trap(() => invoke($1, `i64.store`, [-7n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:133
+assert_trap(() => invoke($1, `i64.store`, [-8n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:134
+assert_trap(() => invoke($1, `f32.store`, [65536n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:135
+assert_trap(() => invoke($1, `f32.store`, [65535n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:136
+assert_trap(() => invoke($1, `f32.store`, [65534n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:137
+assert_trap(() => invoke($1, `f32.store`, [65533n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:138
+assert_trap(() => invoke($1, `f32.store`, [-1n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:139
+assert_trap(() => invoke($1, `f32.store`, [-2n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:140
+assert_trap(() => invoke($1, `f32.store`, [-3n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:141
+assert_trap(() => invoke($1, `f32.store`, [-4n, value("f32", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:142
+assert_trap(() => invoke($1, `f64.store`, [65536n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:143
+assert_trap(() => invoke($1, `f64.store`, [65535n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:144
+assert_trap(() => invoke($1, `f64.store`, [65534n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:145
+assert_trap(() => invoke($1, `f64.store`, [65533n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:146
+assert_trap(() => invoke($1, `f64.store`, [65532n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:147
+assert_trap(() => invoke($1, `f64.store`, [65531n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:148
+assert_trap(() => invoke($1, `f64.store`, [65530n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:149
+assert_trap(() => invoke($1, `f64.store`, [65529n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:150
+assert_trap(() => invoke($1, `f64.store`, [-1n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:151
+assert_trap(() => invoke($1, `f64.store`, [-2n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:152
+assert_trap(() => invoke($1, `f64.store`, [-3n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:153
+assert_trap(() => invoke($1, `f64.store`, [-4n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:154
+assert_trap(() => invoke($1, `f64.store`, [-5n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:155
+assert_trap(() => invoke($1, `f64.store`, [-6n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:156
+assert_trap(() => invoke($1, `f64.store`, [-7n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:157
+assert_trap(() => invoke($1, `f64.store`, [-8n, value("f64", 0)]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:158
+assert_trap(() => invoke($1, `i32.store8`, [65536n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:159
+assert_trap(() => invoke($1, `i32.store8`, [-1n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:160
+assert_trap(() => invoke($1, `i32.store16`, [65536n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:161
+assert_trap(() => invoke($1, `i32.store16`, [65535n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:162
+assert_trap(() => invoke($1, `i32.store16`, [-1n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:163
+assert_trap(() => invoke($1, `i32.store16`, [-2n, 0]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:164
+assert_trap(() => invoke($1, `i64.store8`, [65536n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:165
+assert_trap(() => invoke($1, `i64.store8`, [-1n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:166
+assert_trap(() => invoke($1, `i64.store16`, [65536n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:167
+assert_trap(() => invoke($1, `i64.store16`, [65535n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:168
+assert_trap(() => invoke($1, `i64.store16`, [-1n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:169
+assert_trap(() => invoke($1, `i64.store16`, [-2n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:170
+assert_trap(() => invoke($1, `i64.store32`, [65536n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:171
+assert_trap(() => invoke($1, `i64.store32`, [65535n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:172
+assert_trap(() => invoke($1, `i64.store32`, [65534n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:173
+assert_trap(() => invoke($1, `i64.store32`, [65533n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:174
+assert_trap(() => invoke($1, `i64.store32`, [-1n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:175
+assert_trap(() => invoke($1, `i64.store32`, [-2n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:176
+assert_trap(() => invoke($1, `i64.store32`, [-3n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:177
+assert_trap(() => invoke($1, `i64.store32`, [-4n, 0n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:178
+assert_trap(() => invoke($1, `i32.load`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:179
+assert_trap(() => invoke($1, `i32.load`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:180
+assert_trap(() => invoke($1, `i32.load`, [65534n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:181
+assert_trap(() => invoke($1, `i32.load`, [65533n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:182
+assert_trap(() => invoke($1, `i32.load`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:183
+assert_trap(() => invoke($1, `i32.load`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:184
+assert_trap(() => invoke($1, `i32.load`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:185
+assert_trap(() => invoke($1, `i32.load`, [-4n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:186
+assert_trap(() => invoke($1, `i64.load`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:187
+assert_trap(() => invoke($1, `i64.load`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:188
+assert_trap(() => invoke($1, `i64.load`, [65534n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:189
+assert_trap(() => invoke($1, `i64.load`, [65533n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:190
+assert_trap(() => invoke($1, `i64.load`, [65532n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:191
+assert_trap(() => invoke($1, `i64.load`, [65531n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:192
+assert_trap(() => invoke($1, `i64.load`, [65530n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:193
+assert_trap(() => invoke($1, `i64.load`, [65529n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:194
+assert_trap(() => invoke($1, `i64.load`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:195
+assert_trap(() => invoke($1, `i64.load`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:196
+assert_trap(() => invoke($1, `i64.load`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:197
+assert_trap(() => invoke($1, `i64.load`, [-4n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:198
+assert_trap(() => invoke($1, `i64.load`, [-5n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:199
+assert_trap(() => invoke($1, `i64.load`, [-6n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:200
+assert_trap(() => invoke($1, `i64.load`, [-7n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:201
+assert_trap(() => invoke($1, `i64.load`, [-8n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:202
+assert_trap(() => invoke($1, `f32.load`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:203
+assert_trap(() => invoke($1, `f32.load`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:204
+assert_trap(() => invoke($1, `f32.load`, [65534n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:205
+assert_trap(() => invoke($1, `f32.load`, [65533n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:206
+assert_trap(() => invoke($1, `f32.load`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:207
+assert_trap(() => invoke($1, `f32.load`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:208
+assert_trap(() => invoke($1, `f32.load`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:209
+assert_trap(() => invoke($1, `f32.load`, [-4n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:210
+assert_trap(() => invoke($1, `f64.load`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:211
+assert_trap(() => invoke($1, `f64.load`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:212
+assert_trap(() => invoke($1, `f64.load`, [65534n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:213
+assert_trap(() => invoke($1, `f64.load`, [65533n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:214
+assert_trap(() => invoke($1, `f64.load`, [65532n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:215
+assert_trap(() => invoke($1, `f64.load`, [65531n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:216
+assert_trap(() => invoke($1, `f64.load`, [65530n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:217
+assert_trap(() => invoke($1, `f64.load`, [65529n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:218
+assert_trap(() => invoke($1, `f64.load`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:219
+assert_trap(() => invoke($1, `f64.load`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:220
+assert_trap(() => invoke($1, `f64.load`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:221
+assert_trap(() => invoke($1, `f64.load`, [-4n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:222
+assert_trap(() => invoke($1, `f64.load`, [-5n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:223
+assert_trap(() => invoke($1, `f64.load`, [-6n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:224
+assert_trap(() => invoke($1, `f64.load`, [-7n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:225
+assert_trap(() => invoke($1, `f64.load`, [-8n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:226
+assert_trap(() => invoke($1, `i32.load8_s`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:227
+assert_trap(() => invoke($1, `i32.load8_s`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:228
+assert_trap(() => invoke($1, `i32.load8_u`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:229
+assert_trap(() => invoke($1, `i32.load8_u`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:230
+assert_trap(() => invoke($1, `i32.load16_s`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:231
+assert_trap(() => invoke($1, `i32.load16_s`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:232
+assert_trap(() => invoke($1, `i32.load16_s`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:233
+assert_trap(() => invoke($1, `i32.load16_s`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:234
+assert_trap(() => invoke($1, `i32.load16_u`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:235
+assert_trap(() => invoke($1, `i32.load16_u`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:236
+assert_trap(() => invoke($1, `i32.load16_u`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:237
+assert_trap(() => invoke($1, `i32.load16_u`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:238
+assert_trap(() => invoke($1, `i64.load8_s`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:239
+assert_trap(() => invoke($1, `i64.load8_s`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:240
+assert_trap(() => invoke($1, `i64.load8_u`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:241
+assert_trap(() => invoke($1, `i64.load8_u`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:242
+assert_trap(() => invoke($1, `i64.load16_s`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:243
+assert_trap(() => invoke($1, `i64.load16_s`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:244
+assert_trap(() => invoke($1, `i64.load16_s`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:245
+assert_trap(() => invoke($1, `i64.load16_s`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:246
+assert_trap(() => invoke($1, `i64.load16_u`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:247
+assert_trap(() => invoke($1, `i64.load16_u`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:248
+assert_trap(() => invoke($1, `i64.load16_u`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:249
+assert_trap(() => invoke($1, `i64.load16_u`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:250
+assert_trap(() => invoke($1, `i64.load32_s`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:251
+assert_trap(() => invoke($1, `i64.load32_s`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:252
+assert_trap(() => invoke($1, `i64.load32_s`, [65534n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:253
+assert_trap(() => invoke($1, `i64.load32_s`, [65533n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:254
+assert_trap(() => invoke($1, `i64.load32_s`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:255
+assert_trap(() => invoke($1, `i64.load32_s`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:256
+assert_trap(() => invoke($1, `i64.load32_s`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:257
+assert_trap(() => invoke($1, `i64.load32_s`, [-4n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:258
+assert_trap(() => invoke($1, `i64.load32_u`, [65536n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:259
+assert_trap(() => invoke($1, `i64.load32_u`, [65535n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:260
+assert_trap(() => invoke($1, `i64.load32_u`, [65534n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:261
+assert_trap(() => invoke($1, `i64.load32_u`, [65533n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:262
+assert_trap(() => invoke($1, `i64.load32_u`, [-1n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:263
+assert_trap(() => invoke($1, `i64.load32_u`, [-2n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:264
+assert_trap(() => invoke($1, `i64.load32_u`, [-3n]), `out of bounds memory access`);
+
+// ./test/core/memory_trap64.wast:265
+assert_trap(() => invoke($1, `i64.load32_u`, [-4n]), `out of bounds memory access`);
+
+// Bug 1737225 - do not observe the partial store caused by bug 1666747 on
+// some native platforms.
+if (!partialOobWriteMayWritePartialData()) {
+    // ./test/core/memory_trap64.wast:268
+    assert_return(() => invoke($1, `i64.load`, [65528n]), [
+        value("i64", 7523094288207667809n),
+    ]);
+
+    // ./test/core/memory_trap64.wast:269
+    assert_return(() => invoke($1, `i64.load`, [0n]), [
+        value("i64", 7523094288207667809n),
+    ]);
+}
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/directives.txt b/js/src/jit-test/tests/wasm/spec/relaxed-simd/directives.txt
new file mode 100644
index 0000000000..625758af79
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; --wasm-relaxed-simd; skip-if: !wasmRelaxedSimdEnabled()
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/relaxed-simd/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/harness/harness.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/harness/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/harness/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: 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",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/i16x8_relaxed_q15mulr_s.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i16x8_relaxed_q15mulr_s.wast.js
new file mode 100644
index 0000000000..4bfd1d3308
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i16x8_relaxed_q15mulr_s.wast.js
@@ -0,0 +1,49 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/i16x8_relaxed_q15mulr_s.wast
+
+// ./test/core/relaxed-simd/i16x8_relaxed_q15mulr_s.wast:2
+let $0 = instantiate(`(module
+    (func (export "i16x8.relaxed_q15mulr_s") (param v128 v128) (result v128) (i16x8.relaxed_q15mulr_s (local.get 0) (local.get 1)))
+
+    (func (export "i16x8.relaxed_q15mulr_s_cmp") (param v128 v128) (result v128)
+          (i16x8.eq
+            (i16x8.relaxed_q15mulr_s (local.get 0) (local.get 1))
+            (i16x8.relaxed_q15mulr_s (local.get 0) (local.get 1))))
+)`);
+
+// ./test/core/relaxed-simd/i16x8_relaxed_q15mulr_s.wast:12
+assert_return(
+  () => invoke($0, `i16x8.relaxed_q15mulr_s`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x8000, 0x8000, 0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    either(
+      i16x8([0x8000, 0x7fff, 0x7ffe, 0x0, 0x0, 0x0, 0x0, 0x0]),
+      i16x8([0x7fff, 0x7fff, 0x7ffe, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i16x8_relaxed_q15mulr_s.wast:21
+assert_return(
+  () => invoke($0, `i16x8.relaxed_q15mulr_s_cmp`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x8000, 0x8000, 0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js
new file mode 100644
index 0000000000..96ff3bce44
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i32x4_relaxed_trunc.wast.js
@@ -0,0 +1,338 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:3
+let $0 = instantiate(`(module
+    (func (export "i32x4.relaxed_trunc_f32x4_s") (param v128) (result v128) (i32x4.relaxed_trunc_f32x4_s (local.get 0)))
+    (func (export "i32x4.relaxed_trunc_f32x4_u") (param v128) (result v128) (i32x4.relaxed_trunc_f32x4_u (local.get 0)))
+    (func (export "i32x4.relaxed_trunc_f64x2_s_zero") (param v128) (result v128) (i32x4.relaxed_trunc_f64x2_s_zero (local.get 0)))
+    (func (export "i32x4.relaxed_trunc_f64x2_u_zero") (param v128) (result v128) (i32x4.relaxed_trunc_f64x2_u_zero (local.get 0)))
+
+    (func (export "i32x4.relaxed_trunc_f32x4_s_cmp") (param v128) (result v128)
+          (i32x4.eq
+            (i32x4.relaxed_trunc_f32x4_s (local.get 0))
+            (i32x4.relaxed_trunc_f32x4_s (local.get 0))))
+    (func (export "i32x4.relaxed_trunc_f32x4_u_cmp") (param v128) (result v128)
+          (i32x4.eq
+            (i32x4.relaxed_trunc_f32x4_u (local.get 0))
+            (i32x4.relaxed_trunc_f32x4_u (local.get 0))))
+    (func (export "i32x4.relaxed_trunc_f64x2_s_zero_cmp") (param v128) (result v128)
+          (i32x4.eq
+            (i32x4.relaxed_trunc_f64x2_s_zero (local.get 0))
+            (i32x4.relaxed_trunc_f64x2_s_zero (local.get 0))))
+    (func (export "i32x4.relaxed_trunc_f64x2_u_zero_cmp") (param v128) (result v128)
+          (i32x4.eq
+            (i32x4.relaxed_trunc_f64x2_u_zero (local.get 0))
+            (i32x4.relaxed_trunc_f64x2_u_zero (local.get 0))))
+)`);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:35
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_s`, [
+    f32x4([-2147483600, -2147484000, 2, 2147484000]),
+  ]),
+  [
+    either(
+      i32x4([0x80000000, 0x80000000, 0x2, 0x7fffffff]),
+      i32x4([0x80000000, 0x80000000, 0x2, 0x80000000]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:42
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_s`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+    ]),
+  ]),
+  [
+    either(
+      i32x4([0x0, 0x0, 0x0, 0x0]),
+      i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:48
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_u`, [
+    f32x4([0, -1, 4294967000, 4294967300]),
+  ]),
+  [
+    either(
+      i32x4([0x0, 0x0, 0xffffff00, 0xffffffff]),
+      i32x4([0x0, 0xffffffff, 0xffffff00, 0xffffffff]),
+      i32x4([0x0, 0xffffffff, 0xffffff00, 0x0]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:55
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_u`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+    ]),
+  ]),
+  [
+    either(
+      i32x4([0x0, 0x0, 0x0, 0x0]),
+      i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+      i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:61
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_s_zero`, [
+    f64x2([-2147483904, 2147483904]),
+  ]),
+  [
+    either(
+      i32x4([0x80000000, 0x7fffffff, 0x0, 0x0]),
+      i32x4([0x80000000, 0x80000000, 0x0, 0x0]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:67
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_s_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    either(i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x80000000, 0x80000000, 0x0, 0x0])),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:72
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_u_zero`, [f64x2([-1, 4294967296])]),
+  [
+    either(
+      i32x4([0x0, 0xffffffff, 0x0, 0x0]),
+      i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+      i32x4([0xfffffffe, 0x0, 0x0, 0x0]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:78
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_u_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    either(i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])),
+  ],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:85
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_s_cmp`, [
+    f32x4([-2147483600, -2147484000, 2147483600, 2147484000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:91
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_s_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:96
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_u_cmp`, [
+    f32x4([0, -1, 4294967000, 4294967300]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:102
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f32x4_u_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:107
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_s_zero_cmp`, [
+    f64x2([-2147483904, 2147483904]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:112
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_s_zero_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:116
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_u_zero_cmp`, [f64x2([-1, 4294967296])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/i32x4_relaxed_trunc.wast:121
+assert_return(
+  () => invoke($0, `i32x4.relaxed_trunc_f64x2_u_zero_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/i8x16_relaxed_swizzle.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i8x16_relaxed_swizzle.wast.js
new file mode 100644
index 0000000000..dd77c2b074
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/i8x16_relaxed_swizzle.wast.js
@@ -0,0 +1,90 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast:3
+let $0 = instantiate(`(module
+    (func (export "i8x16.relaxed_swizzle") (param v128 v128) (result v128) (i8x16.relaxed_swizzle (local.get 0) (local.get 1)))
+
+    (func (export "i8x16.relaxed_swizzle_cmp") (param v128 v128) (result v128)
+          (i8x16.eq
+            (i8x16.relaxed_swizzle (local.get 0) (local.get 1))
+            (i8x16.relaxed_swizzle (local.get 0) (local.get 1))))
+)`);
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast:12
+assert_return(
+  () => invoke($0, `i8x16.relaxed_swizzle`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    either(
+      i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+      i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast:19
+assert_return(
+  () => invoke($0, `i8x16.relaxed_swizzle`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+  ]),
+  [
+    either(
+      i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+      i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast:26
+assert_return(
+  () => invoke($0, `i8x16.relaxed_swizzle`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    either(
+      i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+      i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast:35
+assert_return(
+  () => invoke($0, `i8x16.relaxed_swizzle_cmp`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/relaxed-simd/i8x16_relaxed_swizzle.wast:41
+assert_return(
+  () => invoke($0, `i8x16.relaxed_swizzle_cmp`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_dot_product.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_dot_product.wast.js
new file mode 100644
index 0000000000..1c10428515
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_dot_product.wast.js
@@ -0,0 +1,139 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:3
+let $0 = instantiate(`(module
+    (func (export "i16x8.relaxed_dot_i8x16_i7x16_s") (param v128 v128) (result v128) (i16x8.relaxed_dot_i8x16_i7x16_s (local.get 0) (local.get 1)))
+    (func (export "i32x4.relaxed_dot_i8x16_i7x16_add_s") (param v128 v128 v128) (result v128) (i32x4.relaxed_dot_i8x16_i7x16_add_s (local.get 0) (local.get 1) (local.get 2)))
+
+    (func (export "i16x8.relaxed_dot_i8x16_i7x16_s_cmp") (param v128 v128) (result v128)
+          (i16x8.eq
+            (i16x8.relaxed_dot_i8x16_i7x16_s (local.get 0) (local.get 1))
+            (i16x8.relaxed_dot_i8x16_i7x16_s (local.get 0) (local.get 1))))
+    (func (export "i32x4.relaxed_dot_i8x16_i7x16_add_s_cmp") (param v128 v128 v128) (result v128)
+          (i16x8.eq
+            (i32x4.relaxed_dot_i8x16_i7x16_add_s (local.get 0) (local.get 1) (local.get 2))
+            (i32x4.relaxed_dot_i8x16_i7x16_add_s (local.get 0) (local.get 1) (local.get 2))))
+)`);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:18
+assert_return(
+  () => invoke($0, `i16x8.relaxed_dot_i8x16_i7x16_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x1, 0xd, 0x29, 0x55, 0x91, 0xdd, 0x139, 0x1a5])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:24
+assert_return(
+  () => invoke($0, `i16x8.relaxed_dot_i8x16_i7x16_s`, [
+    i8x16([0x80, 0x80, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x8100, 0x7e02, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:32
+assert_return(
+  () => invoke($0, `i16x8.relaxed_dot_i8x16_i7x16_s`, [
+    i8x16([0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x81, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    either(
+      i16x8([0x8000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+      i16x8([0x7f00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+      i16x8([0x8100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:41
+assert_return(
+  () => invoke($0, `i32x4.relaxed_dot_i8x16_i7x16_add_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+  ]),
+  [i32x4([0xe, 0x7f, 0x170, 0x2e1])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:49
+assert_return(
+  () => invoke($0, `i32x4.relaxed_dot_i8x16_i7x16_add_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+  ]),
+  [i32x4([0xffff0201, 0xfc06, 0x3, 0x4])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:62
+assert_return(
+  () => invoke($0, `i32x4.relaxed_dot_i8x16_i7x16_add_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+  ]),
+  [
+    either(
+      i32x4([0xfffefe01, 0x2, 0x3, 0x4]),
+      i32x4([0xffff0001, 0x2, 0x3, 0x4]),
+      i32x4([0xfe01, 0x2, 0x3, 0x4]),
+      i32x4([0x10201, 0x2, 0x3, 0x4]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:75
+assert_return(
+  () => invoke($0, `i16x8.relaxed_dot_i8x16_i7x16_s_cmp`, [
+    i8x16([0x80, 0x80, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:81
+assert_return(
+  () => invoke($0, `i32x4.relaxed_dot_i8x16_i7x16_add_s_cmp`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:91
+assert_return(
+  () => invoke($0, `i16x8.relaxed_dot_i8x16_i7x16_s_cmp`, [
+    i8x16([0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x81, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_dot_product.wast:102
+assert_return(
+  () => invoke($0, `i32x4.relaxed_dot_i8x16_i7x16_add_s_cmp`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_laneselect.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_laneselect.wast.js
new file mode 100644
index 0000000000..2fa9b5fbae
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_laneselect.wast.js
@@ -0,0 +1,163 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:3
+let $0 = instantiate(`(module
+    (func (export "i8x16.relaxed_laneselect") (param v128 v128 v128) (result v128) (i8x16.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2)))
+    (func (export "i16x8.relaxed_laneselect") (param v128 v128 v128) (result v128) (i16x8.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2)))
+    (func (export "i32x4.relaxed_laneselect") (param v128 v128 v128) (result v128) (i32x4.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2)))
+    (func (export "i64x2.relaxed_laneselect") (param v128 v128 v128) (result v128) (i64x2.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2)))
+
+    (func (export "i8x16.relaxed_laneselect_cmp") (param v128 v128 v128) (result v128)
+          (i8x16.eq
+            (i8x16.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))
+            (i8x16.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))))
+    (func (export "i16x8.relaxed_laneselect_cmp") (param v128 v128 v128) (result v128)
+          (i16x8.eq
+            (i16x8.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))
+            (i16x8.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))))
+    (func (export "i32x4.relaxed_laneselect_cmp") (param v128 v128 v128) (result v128)
+          (i32x4.eq
+            (i32x4.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))
+            (i32x4.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))))
+    (func (export "i64x2.relaxed_laneselect_cmp") (param v128 v128 v128) (result v128)
+          (i64x2.eq
+            (i64x2.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))
+            (i64x2.relaxed_laneselect (local.get 0) (local.get 1) (local.get 2))))
+)`);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:27
+assert_return(
+  () => invoke($0, `i8x16.relaxed_laneselect`, [
+    i8x16([0x0, 0x1, 0x12, 0x12, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x10, 0x11, 0x34, 0x34, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+    i8x16([0xff, 0x0, 0xf0, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    either(
+      i8x16([0x0, 0x11, 0x14, 0x32, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+      i8x16([0x0, 0x11, 0x12, 0x34, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:34
+assert_return(
+  () => invoke($0, `i16x8.relaxed_laneselect`, [
+    i16x8([0x0, 0x1, 0x1234, 0x1234, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x8, 0x9, 0x5678, 0x5678, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0xffff, 0x0, 0xff00, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    either(
+      i16x8([0x0, 0x9, 0x1278, 0x5634, 0xc, 0xd, 0xe, 0xf]),
+      i16x8([0x0, 0x9, 0x1234, 0x5678, 0xc, 0xd, 0xe, 0xf]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:41
+assert_return(
+  () => invoke($0, `i32x4.relaxed_laneselect`, [
+    i32x4([0x0, 0x1, 0x12341234, 0x12341234]),
+    i32x4([0x4, 0x5, 0x56785678, 0x56785678]),
+    i32x4([0xffffffff, 0x0, 0xffff0000, 0xffff]),
+  ]),
+  [
+    either(
+      i32x4([0x0, 0x5, 0x12345678, 0x56781234]),
+      i32x4([0x0, 0x5, 0x12341234, 0x56785678]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:48
+assert_return(
+  () => invoke($0, `i64x2.relaxed_laneselect`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x2n, 0x3n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [either(i64x2([0x0n, 0x3n]), i64x2([0x0n, 0x3n]))],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:55
+assert_return(
+  () => invoke($0, `i64x2.relaxed_laneselect`, [
+    i64x2([0x1234123412341234n, 0x1234123412341234n]),
+    i64x2([0x5678567856785678n, 0x5678567856785678n]),
+    i64x2([0xffffffff00000000n, 0xffffffffn]),
+  ]),
+  [
+    either(
+      i64x2([0x1234123456785678n, 0x5678567812341234n]),
+      i64x2([0x1234123412341234n, 0x5678567856785678n]),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:64
+assert_return(
+  () => invoke($0, `i8x16.relaxed_laneselect_cmp`, [
+    i8x16([0x0, 0x1, 0x12, 0x12, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x10, 0x11, 0x34, 0x34, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+    i8x16([0xff, 0x0, 0xf0, 0xf, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:70
+assert_return(
+  () => invoke($0, `i16x8.relaxed_laneselect_cmp`, [
+    i16x8([0x0, 0x1, 0x1234, 0x1234, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x8, 0x9, 0x5678, 0x5678, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0xffff, 0x0, 0xff00, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:76
+assert_return(
+  () => invoke($0, `i32x4.relaxed_laneselect_cmp`, [
+    i32x4([0x0, 0x1, 0x12341234, 0x12341234]),
+    i32x4([0x4, 0x5, 0x56785678, 0x56785678]),
+    i32x4([0xffffffff, 0x0, 0xffff0000, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:82
+assert_return(
+  () => invoke($0, `i64x2.relaxed_laneselect_cmp`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x2n, 0x3n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_laneselect.wast:88
+assert_return(
+  () => invoke($0, `i64x2.relaxed_laneselect_cmp`, [
+    i64x2([0x1234123412341234n, 0x1234123412341234n]),
+    i64x2([0x5678567856785678n, 0x5678567856785678n]),
+    i64x2([0xffffffff00000000n, 0xffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_madd_nmadd.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_madd_nmadd.wast.js
new file mode 100644
index 0000000000..8e00698d52
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_madd_nmadd.wast.js
@@ -0,0 +1,325 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:3
+let $0 = instantiate(`(module
+    (func (export "f32x4.relaxed_madd") (param v128 v128 v128) (result v128) (f32x4.relaxed_madd (local.get 0) (local.get 1) (local.get 2)))
+    (func (export "f32x4.relaxed_nmadd") (param v128 v128 v128) (result v128) (f32x4.relaxed_nmadd (local.get 0) (local.get 1) (local.get 2)))
+    (func (export "f64x2.relaxed_nmadd") (param v128 v128 v128) (result v128) (f64x2.relaxed_nmadd (local.get 0) (local.get 1) (local.get 2)))
+    (func (export "f64x2.relaxed_madd") (param v128 v128 v128) (result v128) (f64x2.relaxed_madd (local.get 0) (local.get 1) (local.get 2)))
+
+    (func (export "f32x4.relaxed_madd_cmp") (param v128 v128 v128) (result v128)
+          (f32x4.eq
+            (f32x4.relaxed_madd (local.get 0) (local.get 1) (local.get 2))
+            (f32x4.relaxed_madd (local.get 0) (local.get 1) (local.get 2))))
+    (func (export "f32x4.relaxed_nmadd_cmp") (param v128 v128 v128) (result v128)
+          (f32x4.eq
+            (f32x4.relaxed_nmadd (local.get 0) (local.get 1) (local.get 2))
+            (f32x4.relaxed_nmadd (local.get 0) (local.get 1) (local.get 2))))
+    (func (export "f64x2.relaxed_nmadd_cmp") (param v128 v128 v128) (result v128)
+          (f64x2.eq
+            (f64x2.relaxed_nmadd (local.get 0) (local.get 1) (local.get 2))
+            (f64x2.relaxed_nmadd (local.get 0) (local.get 1) (local.get 2))))
+    (func (export "f64x2.relaxed_madd_cmp") (param v128 v128 v128) (result v128)
+          (f64x2.eq
+            (f64x2.relaxed_madd (local.get 0) (local.get 1) (local.get 2))
+            (f64x2.relaxed_madd (local.get 0) (local.get 1) (local.get 2))))
+)`);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:33
+assert_return(
+  () => invoke($0, `f32x4.relaxed_madd`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([2, 2, 2, 2]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    either(
+      new F32x4Pattern(
+        value("f32", 340282350000000000000000000000000000000),
+        value("f32", 340282350000000000000000000000000000000),
+        value("f32", 340282350000000000000000000000000000000),
+        value("f32", 340282350000000000000000000000000000000),
+      ),
+      new F32x4Pattern(
+        value("f32", Infinity),
+        value("f32", Infinity),
+        value("f32", Infinity),
+        value("f32", Infinity),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:49
+assert_return(
+  () => invoke($0, `f32x4.relaxed_madd`, [
+    f32x4([1.0000002, 1.0000002, 1.0000002, 1.0000002]),
+    f32x4([1.0000305, 1.0000305, 1.0000305, 1.0000305]),
+    f32x4([-1.0000308, -1.0000308, -1.0000308, -1.0000308]),
+  ]),
+  [
+    either(
+      new F32x4Pattern(
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:56
+assert_return(
+  () => invoke($0, `f32x4.relaxed_nmadd`, [
+    f32x4([-1.0000002, -1.0000002, -1.0000002, -1.0000002]),
+    f32x4([1.0000305, 1.0000305, 1.0000305, 1.0000305]),
+    f32x4([-1.0000308, -1.0000308, -1.0000308, -1.0000308]),
+  ]),
+  [
+    either(
+      new F32x4Pattern(
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:63
+assert_return(
+  () => invoke($0, `f32x4.relaxed_nmadd`, [
+    f32x4([1.0000002, 1.0000002, 1.0000002, 1.0000002]),
+    f32x4([-1.0000305, -1.0000305, -1.0000305, -1.0000305]),
+    f32x4([-1.0000308, -1.0000308, -1.0000308, -1.0000308]),
+  ]),
+  [
+    either(
+      new F32x4Pattern(
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+        value("f32", 0.000000000007275958),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:76
+assert_return(
+  () => invoke($0, `f64x2.relaxed_madd`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2, 2]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(
+        value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+        value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      ),
+      new F64x2Pattern(value("f64", Infinity), value("f64", Infinity)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:92
+assert_return(
+  () => invoke($0, `f64x2.relaxed_madd`, [
+    f64x2([1.0000000009313226, 1.0000000009313226]),
+    f64x2([1.0000001192092896, 1.0000001192092896]),
+    f64x2([-1.0000001201406121, -1.0000001201406121]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(
+        value("f64", 0.00000000000000011102230246251565),
+        value("f64", 0.00000000000000011102230246251565),
+      ),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:99
+assert_return(
+  () => invoke($0, `f64x2.relaxed_nmadd`, [
+    f64x2([-1.0000000009313226, -1.0000000009313226]),
+    f64x2([1.0000001192092896, 1.0000001192092896]),
+    f64x2([-1.0000001201406121, -1.0000001201406121]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(
+        value("f64", 0.00000000000000011102230246251565),
+        value("f64", 0.00000000000000011102230246251565),
+      ),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:106
+assert_return(
+  () => invoke($0, `f64x2.relaxed_nmadd`, [
+    f64x2([1.0000000009313226, 1.0000000009313226]),
+    f64x2([-1.0000001192092896, -1.0000001192092896]),
+    f64x2([-1.0000001201406121, -1.0000001201406121]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(
+        value("f64", 0.00000000000000011102230246251565),
+        value("f64", 0.00000000000000011102230246251565),
+      ),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:120
+assert_return(
+  () => invoke($0, `f32x4.relaxed_madd_cmp`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([2, 2, 2, 2]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:135
+assert_return(
+  () => invoke($0, `f32x4.relaxed_madd_cmp`, [
+    f32x4([1.0000002, 1.0000002, 1.0000002, 1.0000002]),
+    f32x4([1.0000305, 1.0000305, 1.0000305, 1.0000305]),
+    f32x4([-1.0000308, -1.0000308, -1.0000308, -1.0000308]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:141
+assert_return(
+  () => invoke($0, `f32x4.relaxed_nmadd_cmp`, [
+    f32x4([-1.0000002, -1.0000002, -1.0000002, -1.0000002]),
+    f32x4([1.0000305, 1.0000305, 1.0000305, 1.0000305]),
+    f32x4([-1.0000308, -1.0000308, -1.0000308, -1.0000308]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:147
+assert_return(
+  () => invoke($0, `f32x4.relaxed_nmadd_cmp`, [
+    f32x4([1.0000002, 1.0000002, 1.0000002, 1.0000002]),
+    f32x4([-1.0000305, -1.0000305, -1.0000305, -1.0000305]),
+    f32x4([-1.0000308, -1.0000308, -1.0000308, -1.0000308]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:159
+assert_return(
+  () => invoke($0, `f64x2.relaxed_madd_cmp`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2, 2]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:174
+assert_return(
+  () => invoke($0, `f64x2.relaxed_madd_cmp`, [
+    f64x2([1.0000000009313226, 1.0000000009313226]),
+    f64x2([1.0000001192092896, 1.0000001192092896]),
+    f64x2([-1.0000001201406121, -1.0000001201406121]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:180
+assert_return(
+  () => invoke($0, `f64x2.relaxed_nmadd_cmp`, [
+    f64x2([-1.0000000009313226, -1.0000000009313226]),
+    f64x2([1.0000001192092896, 1.0000001192092896]),
+    f64x2([-1.0000001201406121, -1.0000001201406121]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_madd_nmadd.wast:186
+assert_return(
+  () => invoke($0, `f64x2.relaxed_nmadd_cmp`, [
+    f64x2([1.0000000009313226, 1.0000000009313226]),
+    f64x2([-1.0000001192092896, -1.0000001192092896]),
+    f64x2([-1.0000001201406121, -1.0000001201406121]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_min_max.wast.js b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_min_max.wast.js
new file mode 100644
index 0000000000..ea1e75862a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/relaxed-simd/relaxed_min_max.wast.js
@@ -0,0 +1,663 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:3
+let $0 = instantiate(`(module
+    (func (export "f32x4.relaxed_min") (param v128 v128) (result v128) (f32x4.relaxed_min (local.get 0) (local.get 1)))
+    (func (export "f32x4.relaxed_max") (param v128 v128) (result v128) (f32x4.relaxed_max (local.get 0) (local.get 1)))
+    (func (export "f64x2.relaxed_min") (param v128 v128) (result v128) (f64x2.relaxed_min (local.get 0) (local.get 1)))
+    (func (export "f64x2.relaxed_max") (param v128 v128) (result v128) (f64x2.relaxed_max (local.get 0) (local.get 1)))
+
+    (func (export "f32x4.relaxed_min_cmp") (param v128 v128) (result v128)
+          (i32x4.eq
+            (f32x4.relaxed_min (local.get 0) (local.get 1))
+            (f32x4.relaxed_min (local.get 0) (local.get 1))))
+    (func (export "f32x4.relaxed_max_cmp") (param v128 v128) (result v128)
+          (i32x4.eq
+            (f32x4.relaxed_max (local.get 0) (local.get 1))
+            (f32x4.relaxed_max (local.get 0) (local.get 1))))
+    (func (export "f64x2.relaxed_min_cmp") (param v128 v128) (result v128)
+          (i64x2.eq
+            (f64x2.relaxed_min (local.get 0) (local.get 1))
+            (f64x2.relaxed_min (local.get 0) (local.get 1))))
+    (func (export "f64x2.relaxed_max_cmp") (param v128 v128) (result v128)
+          (i64x2.eq
+            (f64x2.relaxed_max (local.get 0) (local.get 1))
+            (f64x2.relaxed_max (local.get 0) (local.get 1))))
+)`);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:27
+assert_return(
+  () => invoke($0, `f32x4.relaxed_min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    either(
+      new F32x4Pattern(
+        `canonical_nan`,
+        `canonical_nan`,
+        `canonical_nan`,
+        `canonical_nan`,
+      ),
+      new F32x4Pattern(
+        `canonical_nan`,
+        `canonical_nan`,
+        value("f32", 0),
+        value("f32", 0),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        `canonical_nan`,
+        `canonical_nan`,
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:35
+assert_return(
+  () => invoke($0, `f32x4.relaxed_min`, [f32x4([0, -0, 0, -0]), f32x4([-0, 0, 0, -0])]),
+  [
+    either(
+      new F32x4Pattern(
+        value("f32", -0),
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+      new F32x4Pattern(
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+      new F32x4Pattern(
+        value("f32", -0),
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:43
+assert_return(
+  () => invoke($0, `f32x4.relaxed_max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    either(
+      new F32x4Pattern(
+        `canonical_nan`,
+        `canonical_nan`,
+        `canonical_nan`,
+        `canonical_nan`,
+      ),
+      new F32x4Pattern(
+        `canonical_nan`,
+        `canonical_nan`,
+        value("f32", 0),
+        value("f32", 0),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        `canonical_nan`,
+        `canonical_nan`,
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:51
+assert_return(
+  () => invoke($0, `f32x4.relaxed_max`, [f32x4([0, -0, 0, -0]), f32x4([-0, 0, 0, -0])]),
+  [
+    either(
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+      new F32x4Pattern(
+        value("f32", 0),
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+      new F32x4Pattern(
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+      new F32x4Pattern(
+        value("f32", -0),
+        value("f32", -0),
+        value("f32", 0),
+        value("f32", -0),
+      ),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:59
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:67
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:75
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min`, [f64x2([0, -0]), f64x2([-0, 0])]),
+  [
+    either(
+      new F64x2Pattern(value("f64", -0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", -0), value("f64", 0)),
+      new F64x2Pattern(value("f64", -0), value("f64", -0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:83
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min`, [f64x2([0, -0]), f64x2([0, -0])]),
+  [
+    either(
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:91
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:99
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    either(
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+      new F64x2Pattern(`canonical_nan`, `canonical_nan`),
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:107
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max`, [f64x2([0, -0]), f64x2([-0, 0])]),
+  [
+    either(
+      new F64x2Pattern(value("f64", 0), value("f64", 0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", -0), value("f64", 0)),
+      new F64x2Pattern(value("f64", -0), value("f64", -0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:115
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max`, [f64x2([0, -0]), f64x2([0, -0])]),
+  [
+    either(
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+      new F64x2Pattern(value("f64", 0), value("f64", -0)),
+    ),
+  ],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:125
+assert_return(
+  () => invoke($0, `f32x4.relaxed_min_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:130
+assert_return(
+  () => invoke($0, `f32x4.relaxed_min_cmp`, [
+    f32x4([0, -0, 0, -0]),
+    f32x4([-0, 0, 0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:135
+assert_return(
+  () => invoke($0, `f32x4.relaxed_max_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:140
+assert_return(
+  () => invoke($0, `f32x4.relaxed_max_cmp`, [
+    f32x4([0, -0, 0, -0]),
+    f32x4([-0, 0, 0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:145
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:150
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min_cmp`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:155
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min_cmp`, [f64x2([0, -0]), f64x2([-0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:160
+assert_return(
+  () => invoke($0, `f64x2.relaxed_min_cmp`, [f64x2([0, -0]), f64x2([0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:165
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max_cmp`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:170
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max_cmp`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:175
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max_cmp`, [f64x2([0, -0]), f64x2([-0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/relaxed-simd/relaxed_min_max.wast:180
+assert_return(
+  () => invoke($0, `f64x2.relaxed_max_cmp`, [f64x2([0, -0]), f64x2([0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/address.wast.js b/js/src/jit-test/tests/wasm/spec/spec/address.wast.js
new file mode 100644
index 0000000000..317c5fdc07
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/address.wast.js
@@ -0,0 +1,1082 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/address.wast
+
+// ./test/core/address.wast:3
+let $0 = instantiate(`(module
+  (memory 1)
+  (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $$i i32) (result i32)
+    (i32.load8_u offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $$i i32) (result i32)
+    (i32.load8_u align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $$i i32) (result i32)
+    (i32.load8_u offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $$i i32) (result i32)
+    (i32.load8_u offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $$i i32) (result i32)
+    (i32.load8_u offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $$i i32) (result i32)
+    (i32.load8_s offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $$i i32) (result i32)
+    (i32.load8_s align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $$i i32) (result i32)
+    (i32.load8_s offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $$i i32) (result i32)
+    (i32.load8_s offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $$i i32) (result i32)
+    (i32.load8_s offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $$i i32) (result i32)
+    (i32.load16_u offset=0 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $$i i32) (result i32)
+    (i32.load16_u align=1 (local.get $$i))                   ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $$i i32) (result i32)
+    (i32.load16_u offset=1 align=1 (local.get $$i))          ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $$i i32) (result i32)
+    (i32.load16_u offset=2 align=2 (local.get $$i))          ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $$i i32) (result i32)
+    (i32.load16_u offset=25 align=2 (local.get $$i))         ;; 122 'z\\0'
+  )
+
+  (func (export "16s_good1") (param $$i i32) (result i32)
+    (i32.load16_s offset=0 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $$i i32) (result i32)
+    (i32.load16_s align=1 (local.get $$i))                   ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $$i i32) (result i32)
+    (i32.load16_s offset=1 align=1 (local.get $$i))          ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $$i i32) (result i32)
+    (i32.load16_s offset=2 align=2 (local.get $$i))          ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $$i i32) (result i32)
+    (i32.load16_s offset=25 align=2 (local.get $$i))         ;; 122 'z\\0'
+  )
+
+  (func (export "32_good1") (param $$i i32) (result i32)
+    (i32.load offset=0 (local.get $$i))                      ;; 1684234849 'abcd'
+  )
+  (func (export "32_good2") (param $$i i32) (result i32)
+    (i32.load align=1 (local.get $$i))                       ;; 1684234849 'abcd'
+  )
+  (func (export "32_good3") (param $$i i32) (result i32)
+    (i32.load offset=1 align=1 (local.get $$i))              ;; 1701077858 'bcde'
+  )
+  (func (export "32_good4") (param $$i i32) (result i32)
+    (i32.load offset=2 align=2 (local.get $$i))              ;; 1717920867 'cdef'
+  )
+  (func (export "32_good5") (param $$i i32) (result i32)
+    (i32.load offset=25 align=4 (local.get $$i))             ;; 122 'z\\0\\0\\0'
+  )
+
+  (func (export "8u_bad") (param $$i i32)
+    (drop (i32.load8_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "8s_bad") (param $$i i32)
+    (drop (i32.load8_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16u_bad") (param $$i i32)
+    (drop (i32.load16_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16s_bad") (param $$i i32)
+    (drop (i32.load16_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "32_bad") (param $$i i32)
+    (drop (i32.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address.wast:104
+assert_return(() => invoke($0, `8u_good1`, [0]), [value("i32", 97)]);
+
+// ./test/core/address.wast:105
+assert_return(() => invoke($0, `8u_good2`, [0]), [value("i32", 97)]);
+
+// ./test/core/address.wast:106
+assert_return(() => invoke($0, `8u_good3`, [0]), [value("i32", 98)]);
+
+// ./test/core/address.wast:107
+assert_return(() => invoke($0, `8u_good4`, [0]), [value("i32", 99)]);
+
+// ./test/core/address.wast:108
+assert_return(() => invoke($0, `8u_good5`, [0]), [value("i32", 122)]);
+
+// ./test/core/address.wast:110
+assert_return(() => invoke($0, `8s_good1`, [0]), [value("i32", 97)]);
+
+// ./test/core/address.wast:111
+assert_return(() => invoke($0, `8s_good2`, [0]), [value("i32", 97)]);
+
+// ./test/core/address.wast:112
+assert_return(() => invoke($0, `8s_good3`, [0]), [value("i32", 98)]);
+
+// ./test/core/address.wast:113
+assert_return(() => invoke($0, `8s_good4`, [0]), [value("i32", 99)]);
+
+// ./test/core/address.wast:114
+assert_return(() => invoke($0, `8s_good5`, [0]), [value("i32", 122)]);
+
+// ./test/core/address.wast:116
+assert_return(() => invoke($0, `16u_good1`, [0]), [value("i32", 25185)]);
+
+// ./test/core/address.wast:117
+assert_return(() => invoke($0, `16u_good2`, [0]), [value("i32", 25185)]);
+
+// ./test/core/address.wast:118
+assert_return(() => invoke($0, `16u_good3`, [0]), [value("i32", 25442)]);
+
+// ./test/core/address.wast:119
+assert_return(() => invoke($0, `16u_good4`, [0]), [value("i32", 25699)]);
+
+// ./test/core/address.wast:120
+assert_return(() => invoke($0, `16u_good5`, [0]), [value("i32", 122)]);
+
+// ./test/core/address.wast:122
+assert_return(() => invoke($0, `16s_good1`, [0]), [value("i32", 25185)]);
+
+// ./test/core/address.wast:123
+assert_return(() => invoke($0, `16s_good2`, [0]), [value("i32", 25185)]);
+
+// ./test/core/address.wast:124
+assert_return(() => invoke($0, `16s_good3`, [0]), [value("i32", 25442)]);
+
+// ./test/core/address.wast:125
+assert_return(() => invoke($0, `16s_good4`, [0]), [value("i32", 25699)]);
+
+// ./test/core/address.wast:126
+assert_return(() => invoke($0, `16s_good5`, [0]), [value("i32", 122)]);
+
+// ./test/core/address.wast:128
+assert_return(() => invoke($0, `32_good1`, [0]), [value("i32", 1684234849)]);
+
+// ./test/core/address.wast:129
+assert_return(() => invoke($0, `32_good2`, [0]), [value("i32", 1684234849)]);
+
+// ./test/core/address.wast:130
+assert_return(() => invoke($0, `32_good3`, [0]), [value("i32", 1701077858)]);
+
+// ./test/core/address.wast:131
+assert_return(() => invoke($0, `32_good4`, [0]), [value("i32", 1717920867)]);
+
+// ./test/core/address.wast:132
+assert_return(() => invoke($0, `32_good5`, [0]), [value("i32", 122)]);
+
+// ./test/core/address.wast:134
+assert_return(() => invoke($0, `8u_good1`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:135
+assert_return(() => invoke($0, `8u_good2`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:136
+assert_return(() => invoke($0, `8u_good3`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:137
+assert_return(() => invoke($0, `8u_good4`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:138
+assert_return(() => invoke($0, `8u_good5`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:140
+assert_return(() => invoke($0, `8s_good1`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:141
+assert_return(() => invoke($0, `8s_good2`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:142
+assert_return(() => invoke($0, `8s_good3`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:143
+assert_return(() => invoke($0, `8s_good4`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:144
+assert_return(() => invoke($0, `8s_good5`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:146
+assert_return(() => invoke($0, `16u_good1`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:147
+assert_return(() => invoke($0, `16u_good2`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:148
+assert_return(() => invoke($0, `16u_good3`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:149
+assert_return(() => invoke($0, `16u_good4`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:150
+assert_return(() => invoke($0, `16u_good5`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:152
+assert_return(() => invoke($0, `16s_good1`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:153
+assert_return(() => invoke($0, `16s_good2`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:154
+assert_return(() => invoke($0, `16s_good3`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:155
+assert_return(() => invoke($0, `16s_good4`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:156
+assert_return(() => invoke($0, `16s_good5`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:158
+assert_return(() => invoke($0, `32_good1`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:159
+assert_return(() => invoke($0, `32_good2`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:160
+assert_return(() => invoke($0, `32_good3`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:161
+assert_return(() => invoke($0, `32_good4`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:162
+assert_return(() => invoke($0, `32_good5`, [65507]), [value("i32", 0)]);
+
+// ./test/core/address.wast:164
+assert_return(() => invoke($0, `8u_good1`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:165
+assert_return(() => invoke($0, `8u_good2`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:166
+assert_return(() => invoke($0, `8u_good3`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:167
+assert_return(() => invoke($0, `8u_good4`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:168
+assert_return(() => invoke($0, `8u_good5`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:170
+assert_return(() => invoke($0, `8s_good1`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:171
+assert_return(() => invoke($0, `8s_good2`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:172
+assert_return(() => invoke($0, `8s_good3`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:173
+assert_return(() => invoke($0, `8s_good4`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:174
+assert_return(() => invoke($0, `8s_good5`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:176
+assert_return(() => invoke($0, `16u_good1`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:177
+assert_return(() => invoke($0, `16u_good2`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:178
+assert_return(() => invoke($0, `16u_good3`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:179
+assert_return(() => invoke($0, `16u_good4`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:180
+assert_return(() => invoke($0, `16u_good5`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:182
+assert_return(() => invoke($0, `16s_good1`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:183
+assert_return(() => invoke($0, `16s_good2`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:184
+assert_return(() => invoke($0, `16s_good3`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:185
+assert_return(() => invoke($0, `16s_good4`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:186
+assert_return(() => invoke($0, `16s_good5`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:188
+assert_return(() => invoke($0, `32_good1`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:189
+assert_return(() => invoke($0, `32_good2`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:190
+assert_return(() => invoke($0, `32_good3`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:191
+assert_return(() => invoke($0, `32_good4`, [65508]), [value("i32", 0)]);
+
+// ./test/core/address.wast:192
+assert_trap(() => invoke($0, `32_good5`, [65508]), `out of bounds memory access`);
+
+// ./test/core/address.wast:194
+assert_trap(() => invoke($0, `8u_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:195
+assert_trap(() => invoke($0, `8s_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:196
+assert_trap(() => invoke($0, `16u_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:197
+assert_trap(() => invoke($0, `16s_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:198
+assert_trap(() => invoke($0, `32_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:199
+assert_trap(() => invoke($0, `32_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:201
+assert_trap(() => invoke($0, `8u_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:202
+assert_trap(() => invoke($0, `8s_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:203
+assert_trap(() => invoke($0, `16u_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:204
+assert_trap(() => invoke($0, `16s_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:205
+assert_trap(() => invoke($0, `32_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:207
+assert_trap(() => invoke($0, `8u_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:208
+assert_trap(() => invoke($0, `8s_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:209
+assert_trap(() => invoke($0, `16u_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:210
+assert_trap(() => invoke($0, `16s_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:211
+assert_trap(() => invoke($0, `32_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:213
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i32.load offset=4294967296 (i32.const 0)))) `),
+  `i32 constant`,
+);
+
+// ./test/core/address.wast:223
+let $1 = instantiate(`(module
+  (memory 1)
+  (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $$i i32) (result i64)
+    (i64.load8_u offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $$i i32) (result i64)
+    (i64.load8_u align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $$i i32) (result i64)
+    (i64.load8_u offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $$i i32) (result i64)
+    (i64.load8_u offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $$i i32) (result i64)
+    (i64.load8_u offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $$i i32) (result i64)
+    (i64.load8_s offset=0 (local.get $$i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $$i i32) (result i64)
+    (i64.load8_s align=1 (local.get $$i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $$i i32) (result i64)
+    (i64.load8_s offset=1 align=1 (local.get $$i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $$i i32) (result i64)
+    (i64.load8_s offset=2 align=1 (local.get $$i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $$i i32) (result i64)
+    (i64.load8_s offset=25 align=1 (local.get $$i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $$i i32) (result i64)
+    (i64.load16_u offset=0 (local.get $$i))                 ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $$i i32) (result i64)
+    (i64.load16_u align=1 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $$i i32) (result i64)
+    (i64.load16_u offset=1 align=1 (local.get $$i))         ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $$i i32) (result i64)
+    (i64.load16_u offset=2 align=2 (local.get $$i))         ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $$i i32) (result i64)
+    (i64.load16_u offset=25 align=2 (local.get $$i))        ;; 122 'z\\0'
+  )
+
+  (func (export "16s_good1") (param $$i i32) (result i64)
+    (i64.load16_s offset=0 (local.get $$i))                 ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $$i i32) (result i64)
+    (i64.load16_s align=1 (local.get $$i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $$i i32) (result i64)
+    (i64.load16_s offset=1 align=1 (local.get $$i))         ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $$i i32) (result i64)
+    (i64.load16_s offset=2 align=2 (local.get $$i))         ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $$i i32) (result i64)
+    (i64.load16_s offset=25 align=2 (local.get $$i))        ;; 122 'z\\0'
+  )
+
+  (func (export "32u_good1") (param $$i i32) (result i64)
+    (i64.load32_u offset=0 (local.get $$i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good2") (param $$i i32) (result i64)
+    (i64.load32_u align=1 (local.get $$i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good3") (param $$i i32) (result i64)
+    (i64.load32_u offset=1 align=1 (local.get $$i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32u_good4") (param $$i i32) (result i64)
+    (i64.load32_u offset=2 align=2 (local.get $$i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32u_good5") (param $$i i32) (result i64)
+    (i64.load32_u offset=25 align=4 (local.get $$i))        ;; 122 'z\\0\\0\\0'
+  )
+
+  (func (export "32s_good1") (param $$i i32) (result i64)
+    (i64.load32_s offset=0 (local.get $$i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good2") (param $$i i32) (result i64)
+    (i64.load32_s align=1 (local.get $$i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good3") (param $$i i32) (result i64)
+    (i64.load32_s offset=1 align=1 (local.get $$i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32s_good4") (param $$i i32) (result i64)
+    (i64.load32_s offset=2 align=2 (local.get $$i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32s_good5") (param $$i i32) (result i64)
+    (i64.load32_s offset=25 align=4 (local.get $$i))        ;; 122 'z\\0\\0\\0'
+  )
+
+  (func (export "64_good1") (param $$i i32) (result i64)
+    (i64.load offset=0 (local.get $$i))                     ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good2") (param $$i i32) (result i64)
+    (i64.load align=1 (local.get $$i))                      ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good3") (param $$i i32) (result i64)
+    (i64.load offset=1 align=1 (local.get $$i))             ;; 0x6968676665646362 'bcdefghi'
+  )
+  (func (export "64_good4") (param $$i i32) (result i64)
+    (i64.load offset=2 align=2 (local.get $$i))             ;; 0x6a69686766656463 'cdefghij'
+  )
+  (func (export "64_good5") (param $$i i32) (result i64)
+    (i64.load offset=25 align=8 (local.get $$i))            ;; 122 'z\\0\\0\\0\\0\\0\\0\\0'
+  )
+
+  (func (export "8u_bad") (param $$i i32)
+    (drop (i64.load8_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "8s_bad") (param $$i i32)
+    (drop (i64.load8_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16u_bad") (param $$i i32)
+    (drop (i64.load16_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "16s_bad") (param $$i i32)
+    (drop (i64.load16_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "32u_bad") (param $$i i32)
+    (drop (i64.load32_u offset=4294967295 (local.get $$i)))
+  )
+  (func (export "32s_bad") (param $$i i32)
+    (drop (i64.load32_s offset=4294967295 (local.get $$i)))
+  )
+  (func (export "64_bad") (param $$i i32)
+    (drop (i64.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address.wast:362
+assert_return(() => invoke($1, `8u_good1`, [0]), [value("i64", 97n)]);
+
+// ./test/core/address.wast:363
+assert_return(() => invoke($1, `8u_good2`, [0]), [value("i64", 97n)]);
+
+// ./test/core/address.wast:364
+assert_return(() => invoke($1, `8u_good3`, [0]), [value("i64", 98n)]);
+
+// ./test/core/address.wast:365
+assert_return(() => invoke($1, `8u_good4`, [0]), [value("i64", 99n)]);
+
+// ./test/core/address.wast:366
+assert_return(() => invoke($1, `8u_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:368
+assert_return(() => invoke($1, `8s_good1`, [0]), [value("i64", 97n)]);
+
+// ./test/core/address.wast:369
+assert_return(() => invoke($1, `8s_good2`, [0]), [value("i64", 97n)]);
+
+// ./test/core/address.wast:370
+assert_return(() => invoke($1, `8s_good3`, [0]), [value("i64", 98n)]);
+
+// ./test/core/address.wast:371
+assert_return(() => invoke($1, `8s_good4`, [0]), [value("i64", 99n)]);
+
+// ./test/core/address.wast:372
+assert_return(() => invoke($1, `8s_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:374
+assert_return(() => invoke($1, `16u_good1`, [0]), [value("i64", 25185n)]);
+
+// ./test/core/address.wast:375
+assert_return(() => invoke($1, `16u_good2`, [0]), [value("i64", 25185n)]);
+
+// ./test/core/address.wast:376
+assert_return(() => invoke($1, `16u_good3`, [0]), [value("i64", 25442n)]);
+
+// ./test/core/address.wast:377
+assert_return(() => invoke($1, `16u_good4`, [0]), [value("i64", 25699n)]);
+
+// ./test/core/address.wast:378
+assert_return(() => invoke($1, `16u_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:380
+assert_return(() => invoke($1, `16s_good1`, [0]), [value("i64", 25185n)]);
+
+// ./test/core/address.wast:381
+assert_return(() => invoke($1, `16s_good2`, [0]), [value("i64", 25185n)]);
+
+// ./test/core/address.wast:382
+assert_return(() => invoke($1, `16s_good3`, [0]), [value("i64", 25442n)]);
+
+// ./test/core/address.wast:383
+assert_return(() => invoke($1, `16s_good4`, [0]), [value("i64", 25699n)]);
+
+// ./test/core/address.wast:384
+assert_return(() => invoke($1, `16s_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:386
+assert_return(() => invoke($1, `32u_good1`, [0]), [value("i64", 1684234849n)]);
+
+// ./test/core/address.wast:387
+assert_return(() => invoke($1, `32u_good2`, [0]), [value("i64", 1684234849n)]);
+
+// ./test/core/address.wast:388
+assert_return(() => invoke($1, `32u_good3`, [0]), [value("i64", 1701077858n)]);
+
+// ./test/core/address.wast:389
+assert_return(() => invoke($1, `32u_good4`, [0]), [value("i64", 1717920867n)]);
+
+// ./test/core/address.wast:390
+assert_return(() => invoke($1, `32u_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:392
+assert_return(() => invoke($1, `32s_good1`, [0]), [value("i64", 1684234849n)]);
+
+// ./test/core/address.wast:393
+assert_return(() => invoke($1, `32s_good2`, [0]), [value("i64", 1684234849n)]);
+
+// ./test/core/address.wast:394
+assert_return(() => invoke($1, `32s_good3`, [0]), [value("i64", 1701077858n)]);
+
+// ./test/core/address.wast:395
+assert_return(() => invoke($1, `32s_good4`, [0]), [value("i64", 1717920867n)]);
+
+// ./test/core/address.wast:396
+assert_return(() => invoke($1, `32s_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:398
+assert_return(() => invoke($1, `64_good1`, [0]), [value("i64", 7523094288207667809n)]);
+
+// ./test/core/address.wast:399
+assert_return(() => invoke($1, `64_good2`, [0]), [value("i64", 7523094288207667809n)]);
+
+// ./test/core/address.wast:400
+assert_return(() => invoke($1, `64_good3`, [0]), [value("i64", 7595434461045744482n)]);
+
+// ./test/core/address.wast:401
+assert_return(() => invoke($1, `64_good4`, [0]), [value("i64", 7667774633883821155n)]);
+
+// ./test/core/address.wast:402
+assert_return(() => invoke($1, `64_good5`, [0]), [value("i64", 122n)]);
+
+// ./test/core/address.wast:404
+assert_return(() => invoke($1, `8u_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:405
+assert_return(() => invoke($1, `8u_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:406
+assert_return(() => invoke($1, `8u_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:407
+assert_return(() => invoke($1, `8u_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:408
+assert_return(() => invoke($1, `8u_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:410
+assert_return(() => invoke($1, `8s_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:411
+assert_return(() => invoke($1, `8s_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:412
+assert_return(() => invoke($1, `8s_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:413
+assert_return(() => invoke($1, `8s_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:414
+assert_return(() => invoke($1, `8s_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:416
+assert_return(() => invoke($1, `16u_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:417
+assert_return(() => invoke($1, `16u_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:418
+assert_return(() => invoke($1, `16u_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:419
+assert_return(() => invoke($1, `16u_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:420
+assert_return(() => invoke($1, `16u_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:422
+assert_return(() => invoke($1, `16s_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:423
+assert_return(() => invoke($1, `16s_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:424
+assert_return(() => invoke($1, `16s_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:425
+assert_return(() => invoke($1, `16s_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:426
+assert_return(() => invoke($1, `16s_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:428
+assert_return(() => invoke($1, `32u_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:429
+assert_return(() => invoke($1, `32u_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:430
+assert_return(() => invoke($1, `32u_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:431
+assert_return(() => invoke($1, `32u_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:432
+assert_return(() => invoke($1, `32u_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:434
+assert_return(() => invoke($1, `32s_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:435
+assert_return(() => invoke($1, `32s_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:436
+assert_return(() => invoke($1, `32s_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:437
+assert_return(() => invoke($1, `32s_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:438
+assert_return(() => invoke($1, `32s_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:440
+assert_return(() => invoke($1, `64_good1`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:441
+assert_return(() => invoke($1, `64_good2`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:442
+assert_return(() => invoke($1, `64_good3`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:443
+assert_return(() => invoke($1, `64_good4`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:444
+assert_return(() => invoke($1, `64_good5`, [65503]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:446
+assert_return(() => invoke($1, `8u_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:447
+assert_return(() => invoke($1, `8u_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:448
+assert_return(() => invoke($1, `8u_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:449
+assert_return(() => invoke($1, `8u_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:450
+assert_return(() => invoke($1, `8u_good5`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:452
+assert_return(() => invoke($1, `8s_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:453
+assert_return(() => invoke($1, `8s_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:454
+assert_return(() => invoke($1, `8s_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:455
+assert_return(() => invoke($1, `8s_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:456
+assert_return(() => invoke($1, `8s_good5`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:458
+assert_return(() => invoke($1, `16u_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:459
+assert_return(() => invoke($1, `16u_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:460
+assert_return(() => invoke($1, `16u_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:461
+assert_return(() => invoke($1, `16u_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:462
+assert_return(() => invoke($1, `16u_good5`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:464
+assert_return(() => invoke($1, `16s_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:465
+assert_return(() => invoke($1, `16s_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:466
+assert_return(() => invoke($1, `16s_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:467
+assert_return(() => invoke($1, `16s_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:468
+assert_return(() => invoke($1, `16s_good5`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:470
+assert_return(() => invoke($1, `32u_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:471
+assert_return(() => invoke($1, `32u_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:472
+assert_return(() => invoke($1, `32u_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:473
+assert_return(() => invoke($1, `32u_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:474
+assert_return(() => invoke($1, `32u_good5`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:476
+assert_return(() => invoke($1, `32s_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:477
+assert_return(() => invoke($1, `32s_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:478
+assert_return(() => invoke($1, `32s_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:479
+assert_return(() => invoke($1, `32s_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:480
+assert_return(() => invoke($1, `32s_good5`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:482
+assert_return(() => invoke($1, `64_good1`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:483
+assert_return(() => invoke($1, `64_good2`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:484
+assert_return(() => invoke($1, `64_good3`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:485
+assert_return(() => invoke($1, `64_good4`, [65504]), [value("i64", 0n)]);
+
+// ./test/core/address.wast:486
+assert_trap(() => invoke($1, `64_good5`, [65504]), `out of bounds memory access`);
+
+// ./test/core/address.wast:488
+assert_trap(() => invoke($1, `8u_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:489
+assert_trap(() => invoke($1, `8s_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:490
+assert_trap(() => invoke($1, `16u_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:491
+assert_trap(() => invoke($1, `16s_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:492
+assert_trap(() => invoke($1, `32u_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:493
+assert_trap(() => invoke($1, `32s_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:494
+assert_trap(() => invoke($1, `64_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:496
+assert_trap(() => invoke($1, `8u_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:497
+assert_trap(() => invoke($1, `8s_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:498
+assert_trap(() => invoke($1, `16u_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:499
+assert_trap(() => invoke($1, `16s_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:500
+assert_trap(() => invoke($1, `32u_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:501
+assert_trap(() => invoke($1, `32s_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:502
+assert_trap(() => invoke($1, `64_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:504
+assert_trap(() => invoke($1, `8u_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:505
+assert_trap(() => invoke($1, `8s_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:506
+assert_trap(() => invoke($1, `16u_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:507
+assert_trap(() => invoke($1, `16s_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:508
+assert_trap(() => invoke($1, `32u_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:509
+assert_trap(() => invoke($1, `32s_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:510
+assert_trap(() => invoke($1, `64_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:514
+let $2 = instantiate(`(module
+  (memory 1)
+  (data (i32.const 0) "\\00\\00\\00\\00\\00\\00\\a0\\7f\\01\\00\\d0\\7f")
+
+  (func (export "32_good1") (param $$i i32) (result f32)
+    (f32.load offset=0 (local.get $$i))                   ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good2") (param $$i i32) (result f32)
+    (f32.load align=1 (local.get $$i))                    ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good3") (param $$i i32) (result f32)
+    (f32.load offset=1 align=1 (local.get $$i))           ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good4") (param $$i i32) (result f32)
+    (f32.load offset=2 align=2 (local.get $$i))           ;; 0.0 '\\00\\00\\00\\00'
+  )
+  (func (export "32_good5") (param $$i i32) (result f32)
+    (f32.load offset=8 align=4 (local.get $$i))           ;; nan:0x500001 '\\01\\00\\d0\\7f'
+  )
+  (func (export "32_bad") (param $$i i32)
+    (drop (f32.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address.wast:538
+assert_return(() => invoke($2, `32_good1`, [0]), [value("f32", 0)]);
+
+// ./test/core/address.wast:539
+assert_return(() => invoke($2, `32_good2`, [0]), [value("f32", 0)]);
+
+// ./test/core/address.wast:540
+assert_return(() => invoke($2, `32_good3`, [0]), [value("f32", 0)]);
+
+// ./test/core/address.wast:541
+assert_return(() => invoke($2, `32_good4`, [0]), [value("f32", 0)]);
+
+// ./test/core/address.wast:542
+assert_return(() => invoke($2, `32_good5`, [0]), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/address.wast:544
+assert_return(() => invoke($2, `32_good1`, [65524]), [value("f32", 0)]);
+
+// ./test/core/address.wast:545
+assert_return(() => invoke($2, `32_good2`, [65524]), [value("f32", 0)]);
+
+// ./test/core/address.wast:546
+assert_return(() => invoke($2, `32_good3`, [65524]), [value("f32", 0)]);
+
+// ./test/core/address.wast:547
+assert_return(() => invoke($2, `32_good4`, [65524]), [value("f32", 0)]);
+
+// ./test/core/address.wast:548
+assert_return(() => invoke($2, `32_good5`, [65524]), [value("f32", 0)]);
+
+// ./test/core/address.wast:550
+assert_return(() => invoke($2, `32_good1`, [65525]), [value("f32", 0)]);
+
+// ./test/core/address.wast:551
+assert_return(() => invoke($2, `32_good2`, [65525]), [value("f32", 0)]);
+
+// ./test/core/address.wast:552
+assert_return(() => invoke($2, `32_good3`, [65525]), [value("f32", 0)]);
+
+// ./test/core/address.wast:553
+assert_return(() => invoke($2, `32_good4`, [65525]), [value("f32", 0)]);
+
+// ./test/core/address.wast:554
+assert_trap(() => invoke($2, `32_good5`, [65525]), `out of bounds memory access`);
+
+// ./test/core/address.wast:556
+assert_trap(() => invoke($2, `32_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:557
+assert_trap(() => invoke($2, `32_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:559
+assert_trap(() => invoke($2, `32_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:560
+assert_trap(() => invoke($2, `32_bad`, [1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:564
+let $3 = instantiate(`(module
+  (memory 1)
+  (data (i32.const 0) "\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\f4\\7f\\01\\00\\00\\00\\00\\00\\fc\\7f")
+
+  (func (export "64_good1") (param $$i i32) (result f64)
+    (f64.load offset=0 (local.get $$i))                     ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good2") (param $$i i32) (result f64)
+    (f64.load align=1 (local.get $$i))                      ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good3") (param $$i i32) (result f64)
+    (f64.load offset=1 align=1 (local.get $$i))             ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good4") (param $$i i32) (result f64)
+    (f64.load offset=2 align=2 (local.get $$i))             ;; 0.0 '\\00\\00\\00\\00\\00\\00\\00\\00'
+  )
+  (func (export "64_good5") (param $$i i32) (result f64)
+    (f64.load offset=18 align=8 (local.get $$i))            ;; nan:0xc000000000001 '\\01\\00\\00\\00\\00\\00\\fc\\7f'
+  )
+  (func (export "64_bad") (param $$i i32)
+    (drop (f64.load offset=4294967295 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/address.wast:588
+assert_return(() => invoke($3, `64_good1`, [0]), [value("f64", 0)]);
+
+// ./test/core/address.wast:589
+assert_return(() => invoke($3, `64_good2`, [0]), [value("f64", 0)]);
+
+// ./test/core/address.wast:590
+assert_return(() => invoke($3, `64_good3`, [0]), [value("f64", 0)]);
+
+// ./test/core/address.wast:591
+assert_return(() => invoke($3, `64_good4`, [0]), [value("f64", 0)]);
+
+// ./test/core/address.wast:592
+assert_return(
+  () => invoke($3, `64_good5`, [0]),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
+
+// ./test/core/address.wast:594
+assert_return(() => invoke($3, `64_good1`, [65510]), [value("f64", 0)]);
+
+// ./test/core/address.wast:595
+assert_return(() => invoke($3, `64_good2`, [65510]), [value("f64", 0)]);
+
+// ./test/core/address.wast:596
+assert_return(() => invoke($3, `64_good3`, [65510]), [value("f64", 0)]);
+
+// ./test/core/address.wast:597
+assert_return(() => invoke($3, `64_good4`, [65510]), [value("f64", 0)]);
+
+// ./test/core/address.wast:598
+assert_return(() => invoke($3, `64_good5`, [65510]), [value("f64", 0)]);
+
+// ./test/core/address.wast:600
+assert_return(() => invoke($3, `64_good1`, [65511]), [value("f64", 0)]);
+
+// ./test/core/address.wast:601
+assert_return(() => invoke($3, `64_good2`, [65511]), [value("f64", 0)]);
+
+// ./test/core/address.wast:602
+assert_return(() => invoke($3, `64_good3`, [65511]), [value("f64", 0)]);
+
+// ./test/core/address.wast:603
+assert_return(() => invoke($3, `64_good4`, [65511]), [value("f64", 0)]);
+
+// ./test/core/address.wast:604
+assert_trap(() => invoke($3, `64_good5`, [65511]), `out of bounds memory access`);
+
+// ./test/core/address.wast:606
+assert_trap(() => invoke($3, `64_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:607
+assert_trap(() => invoke($3, `64_good3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/address.wast:609
+assert_trap(() => invoke($3, `64_bad`, [0]), `out of bounds memory access`);
+
+// ./test/core/address.wast:610
+assert_trap(() => invoke($3, `64_bad`, [1]), `out of bounds memory access`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/block.wast.js b/js/src/jit-test/tests/wasm/spec/spec/block.wast.js
new file mode 100644
index 0000000000..17a8db0774
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/block.wast.js
@@ -0,0 +1,1878 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/block.wast
+
+// ./test/core/block.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "empty")
+    (block)
+    (block $$l)
+  )
+
+  (func (export "singular") (result i32)
+    (block (nop))
+    (block (result i32) (i32.const 7))
+  )
+
+  (func (export "multi") (result i32)
+    (block (call $$dummy) (call $$dummy) (call $$dummy) (call $$dummy))
+    (block (result i32)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i32.const 7) (call $$dummy)
+    )
+    (drop)
+    (block (result i32 i64 i32)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i32.const 8) (call $$dummy)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i64.const 7) (call $$dummy)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i32.const 9) (call $$dummy)
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (result i32)
+    (block (result i32)
+      (block (call $$dummy) (block) (nop))
+      (block (result i32) (call $$dummy) (i32.const 9))
+    )
+  )
+
+  (func (export "deep") (result i32)
+    (block (result i32) (block (result i32)
+      (block (result i32) (block (result i32)
+        (block (result i32) (block (result i32)
+          (block (result i32) (block (result i32)
+            (block (result i32) (block (result i32)
+              (block (result i32) (block (result i32)
+                (block (result i32) (block (result i32)
+                  (block (result i32) (block (result i32)
+                    (block (result i32) (block (result i32)
+                      (block (result i32) (block (result i32)
+                        (block (result i32) (block (result i32)
+                          (block (result i32) (block (result i32)
+                            (block (result i32) (block (result i32)
+                              (block (result i32) (block (result i32)
+                                (block (result i32) (block (result i32)
+                                  (block (result i32) (block (result i32)
+                                    (block (result i32) (block (result i32)
+                                      (block (result i32) (block (result i32)
+                                        (block (result i32) (block (result i32)
+                                          (call $$dummy) (i32.const 150)
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+
+  (func (export "as-select-first") (result i32)
+    (select (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (block (result i32) (i32.const 1)) (call $$dummy) (call $$dummy))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $$dummy) (block (result i32) (i32.const 1)) (call $$dummy))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (call $$dummy) (call $$dummy) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (block (result i32) (i32.const 1)) (if (then (call $$dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (block (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (block (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (block (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (block (result i32) (i32.const 1)))
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $$f (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (block (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (block (result i32) (i32.const 1))))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (block (result i32) (i32.const 1)))
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$a (block (result i32) (i32.const 1)))
+    (global.get $$a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (block (result i32) (call $$dummy) (i32.const 13)))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (block (result i32) (call $$dummy) (i32.const 3))
+      (block (result i32) (call $$dummy) (i32.const 4))
+    )
+  )
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (block (result i32) (call $$dummy) (i32.const 13)))
+  )
+  (func (export "as-compare-operand") (result i32)
+    (f32.gt
+      (block (result f32) (call $$dummy) (f32.const 3))
+      (block (result f32) (call $$dummy) (f32.const 3))
+    )
+  )
+  (func (export "as-binary-operands") (result i32)
+    (i32.mul
+      (block (result i32 i32)
+        (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4)
+      )
+    )
+  )
+  (func (export "as-compare-operands") (result i32)
+    (f32.gt
+      (block (result f32 f32)
+        (call $$dummy) (f32.const 3) (call $$dummy) (f32.const 3)
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (result i32)
+    (block (result i32 i32)
+      (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4)
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (block (br 0) (unreachable))
+    (block (br_if 0 (i32.const 1)) (unreachable))
+    (block (br_table 0 (i32.const 0)) (unreachable))
+    (block (br_table 0 0 0 (i32.const 1)) (unreachable))
+    (i32.const 19)
+  )
+  (func (export "break-value") (result i32)
+    (block (result i32) (br 0 (i32.const 18)) (i32.const 19))
+  )
+  (func (export "break-multi-value") (result i32 i32 i64)
+    (block (result i32 i32 i64)
+      (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+      (i32.const 19) (i32.const -19) (i64.const 19)
+    )
+  )
+  (func (export "break-repeated") (result i32)
+    (block (result i32)
+      (br 0 (i32.const 18))
+      (br 0 (i32.const 19))
+      (drop (br_if 0 (i32.const 20) (i32.const 0)))
+      (drop (br_if 0 (i32.const 20) (i32.const 1)))
+      (br 0 (i32.const 21))
+      (br_table 0 (i32.const 22) (i32.const 4))
+      (br_table 0 0 0 (i32.const 23) (i32.const 1))
+      (i32.const 21)
+    )
+  )
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
+    )
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
+    )
+    (local.get 0)
+  )
+
+  (func (export "param") (result i32)
+    (i32.const 1)
+    (block (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+    )
+  )
+  (func (export "params") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32)
+      (i32.add)
+    )
+  )
+  (func (export "params-id") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32 i32))
+    (i32.add)
+  )
+  (func (export "param-break") (result i32)
+    (i32.const 1)
+    (block (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+      (br 0)
+    )
+  )
+  (func (export "params-break") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32)
+      (i32.add)
+      (br 0)
+    )
+  )
+  (func (export "params-id-break") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32 i32) (br 0))
+    (i32.add)
+  )
+
+  (func (export "effects") (result i32)
+    (local i32)
+    (block
+      (local.set 0 (i32.const 1))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+      (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+      (br 0)
+      (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+
+  (type $$block-sig-1 (func))
+  (type $$block-sig-2 (func (result i32)))
+  (type $$block-sig-3 (func (param $$x i32)))
+  (type $$block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (block (type $$block-sig-1))
+    (block (type $$block-sig-2) (i32.const 0))
+    (block (type $$block-sig-3) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (block (type $$block-sig-4))
+    (drop) (drop) (drop)
+    (block (type $$block-sig-2) (result i32) (i32.const 0))
+    (block (type $$block-sig-3) (param i32) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (block (type $$block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+    )
+    (drop) (drop) (drop)
+  )
+)`);
+
+// ./test/core/block.wast:353
+assert_return(() => invoke($0, `empty`, []), []);
+
+// ./test/core/block.wast:354
+assert_return(() => invoke($0, `singular`, []), [value("i32", 7)]);
+
+// ./test/core/block.wast:355
+assert_return(() => invoke($0, `multi`, []), [value("i32", 8)]);
+
+// ./test/core/block.wast:356
+assert_return(() => invoke($0, `nested`, []), [value("i32", 9)]);
+
+// ./test/core/block.wast:357
+assert_return(() => invoke($0, `deep`, []), [value("i32", 150)]);
+
+// ./test/core/block.wast:359
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:360
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/block.wast:361
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/block.wast:363
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:364
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:365
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:367
+assert_return(() => invoke($0, `as-if-condition`, []), []);
+
+// ./test/core/block.wast:368
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:369
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 2)]);
+
+// ./test/core/block.wast:371
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:372
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/block.wast:374
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:375
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/block.wast:377
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:378
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 2)]);
+
+// ./test/core/block.wast:379
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:381
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/block.wast:382
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/block.wast:384
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:385
+assert_return(() => invoke($0, `as-call-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:386
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:387
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/block.wast:388
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:389
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:390
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:391
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:392
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:394
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 0)]);
+
+// ./test/core/block.wast:395
+assert_return(() => invoke($0, `as-binary-operand`, []), [value("i32", 12)]);
+
+// ./test/core/block.wast:396
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/block.wast:397
+assert_return(() => invoke($0, `as-compare-operand`, []), [value("i32", 0)]);
+
+// ./test/core/block.wast:398
+assert_return(() => invoke($0, `as-binary-operands`, []), [value("i32", 12)]);
+
+// ./test/core/block.wast:399
+assert_return(() => invoke($0, `as-compare-operands`, []), [value("i32", 0)]);
+
+// ./test/core/block.wast:400
+assert_return(() => invoke($0, `as-mixed-operands`, []), [value("i32", 27)]);
+
+// ./test/core/block.wast:402
+assert_return(() => invoke($0, `break-bare`, []), [value("i32", 19)]);
+
+// ./test/core/block.wast:403
+assert_return(() => invoke($0, `break-value`, []), [value("i32", 18)]);
+
+// ./test/core/block.wast:404
+assert_return(
+  () => invoke($0, `break-multi-value`, []),
+  [value("i32", 18), value("i32", -18), value("i64", 18n)],
+);
+
+// ./test/core/block.wast:407
+assert_return(() => invoke($0, `break-repeated`, []), [value("i32", 18)]);
+
+// ./test/core/block.wast:408
+assert_return(() => invoke($0, `break-inner`, []), [value("i32", 15)]);
+
+// ./test/core/block.wast:410
+assert_return(() => invoke($0, `param`, []), [value("i32", 3)]);
+
+// ./test/core/block.wast:411
+assert_return(() => invoke($0, `params`, []), [value("i32", 3)]);
+
+// ./test/core/block.wast:412
+assert_return(() => invoke($0, `params-id`, []), [value("i32", 3)]);
+
+// ./test/core/block.wast:413
+assert_return(() => invoke($0, `param-break`, []), [value("i32", 3)]);
+
+// ./test/core/block.wast:414
+assert_return(() => invoke($0, `params-break`, []), [value("i32", 3)]);
+
+// ./test/core/block.wast:415
+assert_return(() => invoke($0, `params-id-break`, []), [value("i32", 3)]);
+
+// ./test/core/block.wast:417
+assert_return(() => invoke($0, `effects`, []), [value("i32", 1)]);
+
+// ./test/core/block.wast:419
+assert_return(() => invoke($0, `type-use`, []), []);
+
+// ./test/core/block.wast:421
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (block (type $$sig) (result i32) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:428
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (block (param i32) (type $$sig) (result i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:435
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (block (param i32) (result i32) (type $$sig))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:442
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (block (result i32) (type $$sig) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:449
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (block (result i32) (param i32) (type $$sig))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:456
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (block (result i32) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:463
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (block (param $$x i32) (drop))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:467
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (func (block (type $$sig) (result i32) (i32.const 0)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/block.wast:474
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (block (type $$sig) (result i32) (i32.const 0)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/block.wast:481
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (block (type $$sig) (param i32) (drop)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/block.wast:488
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (func (i32.const 0) (block (type $$sig) (param i32) (result i32)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/block.wast:496
+assert_invalid(
+  () => instantiate(`(module
+    (type $$sig (func))
+    (func (block (type $$sig) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:504
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32) (block)))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:508
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64) (block)))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:512
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32) (block)))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:516
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64) (block)))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:521
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i32-vs-void
+    (block (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:527
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i64-vs-void
+    (block (i64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:533
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f32-vs-void
+    (block (f32.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:539
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f64-vs-void
+    (block (f64.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:545
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-void
+    (block (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:551
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-i32 (result i32)
+    (block (result i32))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:557
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-i64 (result i64)
+    (block (result i64))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:563
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-f32 (result f32)
+    (block (result f32))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:569
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-f64 (result f64)
+    (block (result f64))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:575
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-nums (result i32 i32)
+    (block (result i32 i32))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:582
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-in-block
+      (i32.const 0)
+      (block (block (result i32)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:591
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-in-loop
+      (i32.const 0)
+      (loop (block (result i32)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:600
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (block (result i32)) (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:610
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-i32 (result i32)
+    (block (result i32) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:616
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-i64 (result i64)
+    (block (result i64) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:622
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-f32 (result f32)
+    (block (result f32) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:628
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-f64 (result f64)
+    (block (result f64) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:634
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:640
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i32-vs-i64 (result i32)
+    (block (result i32) (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:646
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i32-vs-f32 (result i32)
+    (block (result i32) (f32.const 0.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:652
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i32-vs-f64 (result i32)
+    (block (result i32) (f64.const 0.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:658
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i64-vs-i32 (result i64)
+    (block (result i64) (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:664
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i64-vs-f32 (result i64)
+    (block (result i64) (f32.const 0.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:670
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-i64-vs-f64 (result i64)
+    (block (result i64) (f64.const 0.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:676
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f32-vs-i32 (result f32)
+    (block (result f32) (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:682
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f32-vs-i64 (result f32)
+    (block (result f32) (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:688
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f32-vs-f64 (result f32)
+    (block (result f32) (f64.const 0.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:694
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f64-vs-i32 (result f64)
+    (block (result f64) (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:700
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f64-vs-i64 (result f64)
+    (block (result f64) (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:706
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-f64-vs-f32 (result f32)
+    (block (result f64) (f32.const 0.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:712
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:718
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-partial-vs-nums (result i32 i32)
+    (i32.const 1) (block (result i32 i32) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:724
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-num (result i32)
+    (block (result i32) (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:731
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-i32-i64 (result i32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:737
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-i32-f32 (result i32)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:743
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-i32-f64 (result i32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:749
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-i64-i32 (result i64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:755
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-i64-f32 (result i64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:761
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-i64-f64 (result i64)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:767
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-f32-i32 (result f32)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:773
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-f32-i64 (result f32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:779
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-f32-f64 (result f32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:785
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-f64-i32 (result f64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:791
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-f64-i64 (result f64)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:797
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select-f64-f32 (result f64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:804
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-i32 (result i32)
+    (block (result i32) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:810
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-i64 (result i64)
+    (block (result i64) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:816
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-f32 (result f32)
+    (block (result f32) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:822
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-f64 (result f64)
+    (block (result f64) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:828
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:835
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-empty-vs-i32 (result i32)
+    (block (result i32) (br 0) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:841
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-empty-vs-i64 (result i64)
+    (block (result i64) (br 0) (i64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:847
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-empty-vs-f32 (result f32)
+    (block (result f32) (br 0) (f32.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:853
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-empty-vs-f64 (result f64)
+    (block (result f64) (br 0) (f64.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:859
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-empty-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0) (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:866
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-i32 (result i32)
+    (block (result i32) (br 0 (nop)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:872
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (i64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:878
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (f32.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:884
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (f64.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:891
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-i32-vs-i64 (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:897
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:903
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:909
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (i64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:915
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (i64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:921
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (i64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:927
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (f32.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:933
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (f32.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:939
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (f32.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:945
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-f64-vs-i32 (result f64)
+    (block (result i64) (br 0 (i32.const 1)) (f64.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:951
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (f64.const 1.0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:957
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (f64.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:963
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:969
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-partial-vs-nums (result i32 i32)
+    (i32.const 1) (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:976
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-void-vs-i32 (result i32)
+    (block (result i32) (br 0 (nop)) (br 0 (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:982
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (br 0 (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:988
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (br 0 (f32.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:994
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (br 0 (f64.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1000
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (nop)) (br 0 (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1007
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-i32-vs-i64 (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1013
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (br 0 (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1019
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (br 0 (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1025
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (br 0 (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1031
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (br 0 (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1037
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (br 0 (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1043
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (br 0 (f32.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1049
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (br 0 (f32.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1055
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (br 0 (f32.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1061
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-f64-vs-i32 (result f64)
+    (block (result f64) (br 0 (i32.const 1)) (br 0 (f64.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1067
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (br 0 (f64.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1073
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (br 0 (f64.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1079
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (i32.const 0)) (br 0 (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1086
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i32-vs-void
+    (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1092
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i64-vs-void
+    (block (result i64) (block (result i64) (br 1 (i64.const 1))) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1098
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f32-vs-void
+    (block (result f32) (block (result f32) (br 1 (f32.const 1.0))) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1104
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f64-vs-void
+    (block (result f64) (block (result f64) (br 1 (f64.const 1.0))) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1110
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-nums-vs-void
+    (block (result i32 i32) (block (result i32 i32) (br 1 (i32.const 1) (i32.const 2))) (br 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1117
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-i32 (result i32)
+    (block (result i32) (block (br 1)) (br 0 (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1123
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-i64 (result i64)
+    (block (result i64) (block (br 1)) (br 0 (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1129
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-f32 (result f32)
+    (block (result f32) (block (br 1)) (br 0 (f32.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1135
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-f64 (result f64)
+    (block (result f64) (block (br 1)) (br 0 (f64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1141
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-nums (result i32 i32)
+    (block (result i32 i32) (block (br 1)) (br 0 (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1148
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-i32 (result i32)
+    (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1154
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-i64 (result i64)
+    (block (result i64) (block (result i64) (br 1 (nop))) (br 0 (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1160
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-f32 (result f32)
+    (block (result f32) (block (result f32) (br 1 (nop))) (br 0 (f32.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1166
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-f64 (result f64)
+    (block (result f64) (block (result f64) (br 1 (nop))) (br 0 (f64.const 1.0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1172
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (block (result i32 i32) (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1179
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i32-vs-i64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1187
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i32-vs-f32 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f32.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1195
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i32-vs-f64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f64.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1203
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i64-vs-i32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (i32.const 1))) (br 0 (i64.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1211
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i64-vs-f32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f32.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1219
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-i64-vs-f64 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f64.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1227
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f32-vs-i32 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i32.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1235
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f32-vs-i64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i64.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1243
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f32-vs-f64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (f64.const 1.0))) (br 0 (f32.const 1.0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1251
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f64-vs-i32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i32.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1259
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f64-vs-i64 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i64.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1267
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-f64-vs-f32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (f32.const 1.0))) (br 0 (f64.const 1.0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1275
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32 i32)
+      (block (result i32 i32) (br 1 (i32.const 0))) (br 0 (i32.const 1) (i32.const 2))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1284
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-empty-vs-i32 (result i32)
+    (i32.ctz (block (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1290
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-empty-vs-i64 (result i64)
+    (i64.ctz (block (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1296
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-empty-vs-f32 (result f32)
+    (f32.floor (block (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1302
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-empty-vs-f64 (result f64)
+    (f64.floor (block (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1308
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-empty-vs-nums (result i32)
+    (i32.add (block (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1315
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-void-vs-i32 (result i32)
+    (i32.ctz (block (br 0 (nop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1321
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-void-vs-i64 (result i64)
+    (i64.ctz (block (br 0 (nop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1327
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-void-vs-f32 (result f32)
+    (f32.floor (block (br 0 (nop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1333
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-void-vs-f64 (result f64)
+    (f64.floor (block (br 0 (nop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1339
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-void-vs-nums (result i32)
+    (i32.add (block (br 0 (nop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1346
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-i32-vs-i64 (result i32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1352
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-i32-vs-f32 (result i32)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1358
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-i32-vs-f64 (result i32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1364
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-i64-vs-i32 (result i64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1370
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-i64-vs-f32 (result i64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1376
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-i64-vs-f64 (result i64)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1382
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-f32-vs-i32 (result f32)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1388
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-f32-vs-i64 (result f32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1394
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-f32-vs-f64 (result f32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1400
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-f64-vs-i32 (result f64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1406
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-f64-vs-i64 (result f64)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1412
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-f64-vs-f32 (result f64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1418
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-operand-num-vs-nums (result i32)
+    (i32.add (block (br 0 (i64.const 9) (i32.const 10))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1425
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-num
+    (block (param i32) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1431
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (block (param i32 f64) (drop) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1437
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (f32.const 0) (block (param i32) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1443
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (f32.const 0) (block (param f32 i32) (drop) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1449
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-nested-void-vs-num
+    (block (block (param i32) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1455
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (block (block (param i32 f64) (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1461
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (block (f32.const 0) (block (param i32) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1467
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (block (f32.const 0) (block (param f32 i32) (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/block.wast:1474
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) block (param $$x i32) end) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:1478
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) (block (param $$x i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/block.wast:1484
+assert_malformed(() => instantiate(`(func block end $$l) `), `mismatching label`);
+
+// ./test/core/block.wast:1488
+assert_malformed(() => instantiate(`(func block $$a end $$l) `), `mismatching label`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/br.wast.js b/js/src/jit-test/tests/wasm/spec/spec/br.wast.js
new file mode 100644
index 0000000000..e4febec2ea
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/br.wast.js
@@ -0,0 +1,839 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/br.wast
+
+// ./test/core/br.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (func $$dummy)
+
+  (func (export "type-i32") (block (drop (i32.ctz (br 0)))))
+  (func (export "type-i64") (block (drop (i64.ctz (br 0)))))
+  (func (export "type-f32") (block (drop (f32.neg (br 0)))))
+  (func (export "type-f64") (block (drop (f64.neg (br 0)))))
+  (func (export "type-i32-i32") (block (drop (i32.add (br 0)))))
+  (func (export "type-i64-i64") (block (drop (i64.add (br 0)))))
+  (func (export "type-f32-f32") (block (drop (f32.add (br 0)))))
+  (func (export "type-f64-f64") (block (drop (f64.add (br 0)))))
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br 0 (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br 0 (i64.const 2))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br 0 (f32.const 3))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br 0 (f64.const 4))))
+  )
+  (func (export "type-f64-f64-value") (result f64 f64)
+    (block (result f64 f64)
+      (f64.add (br 0 (f64.const 4) (f64.const 5))) (f64.const 6)
+    )
+  )
+
+  (func (export "as-block-first")
+    (block (br 0) (call $$dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $$dummy) (br 0) (call $$dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $$dummy) (br 0))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $$dummy) (br 0 (i32.const 2)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $$dummy) (br 1 (i32.const 4)) (i32.const 2))
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (block (result i32)
+      (loop (result i32) (nop) (call $$dummy) (br 1 (i32.const 5)))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br 0)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br 0)))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br 0 (i64.const 7))))
+  )
+  (func (export "as-return-values") (result i32 i64)
+    (i32.const 2)
+    (block (result i64) (return (br 0 (i32.const 1) (i64.const 7))))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32) (br 0 (i32.const 2))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (br 1 (i32.const 3)))
+        (else (local.get 1))
+      )
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (block (result i32)
+      (select (br 0 (i32.const 5)) (local.get 0) (local.get 1))
+    )
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (block (result i32)
+      (select (local.get 0) (br 0 (i32.const 6)) (local.get 1))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7)))
+    )
+  )
+  (func (export "as-select-all") (result i32)
+    (block (result i32) (select (br 0 (i32.const 8))))
+  )
+
+  (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $$f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $$f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $$f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
+    )
+  )
+  (func (export "as-call-all") (result i32)
+    (block (result i32) (call $$f (br 0 (i32.const 15))))
+  )
+
+  (type $$sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$f))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $$sig)
+        (br 0 (i32.const 20))
+        (i32.const 1) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$sig)
+        (i32.const 0)
+        (br 0 (i32.const 21)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$sig)
+        (i32.const 0)
+        (i32.const 1) (br 0 (i32.const 22)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$sig)
+        (i32.const 0)
+        (i32.const 1) (i32.const 2) (br 0 (i32.const 23))
+      )
+    )
+  )
+  (func (export "as-call_indirect-all") (result i32)
+    (block (result i32) (call_indirect (type $$sig) (br 0 (i32.const 24))))
+  )
+
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (block (result i32) (local.set 0 (br 0 (i32.const 17))) (i32.const -1))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (block (result i32) (local.tee 0 (br 0 (i32.const 1))))
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32) (global.set $$a (br 0 (i32.const 1))))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br 0 (f32.const 1.7))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br 0 (i64.const 30))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1)
+    )
+  )
+  (func (export "as-store-both") (result i32)
+    (block (result i32)
+      (i64.store (br 0 (i32.const 32))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-both") (result i32)
+    (block (result i32)
+      (i64.store16 (br 0 (i32.const 34))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.neg (br 0 (f32.const 3.4))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i64)
+    (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45))))
+  )
+  (func (export "as-binary-both") (result i32)
+    (block (result i32) (i32.add (br 0 (i32.const 46))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br 0 (i32.const 44))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42))))
+  )
+  (func (export "as-compare-both") (result i32)
+    (block (result i32) (f64.le (br 0 (i32.const 44))))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (block (result i32) (i32.wrap_i64 (br 0 (i32.const 41))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br 0 (i32.const 40))))
+  )
+
+  (func (export "nested-block-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (call $$dummy)
+        (i32.add (i32.const 4) (br 0 (i32.const 8)))
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (br 0 (br 1 (i32.const 8)))
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1)))
+            (i32.const 32)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8))))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (br_table 0 (br 1 (i32.const 8)) (i32.const 1))
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0 (i32.const 4) (br 0 (i32.const 8)))
+        (i32.const 16)
+      )
+    )
+  )
+)`);
+
+// ./test/core/br.wast:372
+assert_return(() => invoke($0, `type-i32`, []), []);
+
+// ./test/core/br.wast:373
+assert_return(() => invoke($0, `type-i64`, []), []);
+
+// ./test/core/br.wast:374
+assert_return(() => invoke($0, `type-f32`, []), []);
+
+// ./test/core/br.wast:375
+assert_return(() => invoke($0, `type-f64`, []), []);
+
+// ./test/core/br.wast:376
+assert_return(() => invoke($0, `type-i32-i32`, []), []);
+
+// ./test/core/br.wast:377
+assert_return(() => invoke($0, `type-i64-i64`, []), []);
+
+// ./test/core/br.wast:378
+assert_return(() => invoke($0, `type-f32-f32`, []), []);
+
+// ./test/core/br.wast:379
+assert_return(() => invoke($0, `type-f64-f64`, []), []);
+
+// ./test/core/br.wast:381
+assert_return(() => invoke($0, `type-i32-value`, []), [value("i32", 1)]);
+
+// ./test/core/br.wast:382
+assert_return(() => invoke($0, `type-i64-value`, []), [value("i64", 2n)]);
+
+// ./test/core/br.wast:383
+assert_return(() => invoke($0, `type-f32-value`, []), [value("f32", 3)]);
+
+// ./test/core/br.wast:384
+assert_return(() => invoke($0, `type-f64-value`, []), [value("f64", 4)]);
+
+// ./test/core/br.wast:385
+assert_return(() => invoke($0, `type-f64-f64-value`, []), [value("f64", 4), value("f64", 5)]);
+
+// ./test/core/br.wast:387
+assert_return(() => invoke($0, `as-block-first`, []), []);
+
+// ./test/core/br.wast:388
+assert_return(() => invoke($0, `as-block-mid`, []), []);
+
+// ./test/core/br.wast:389
+assert_return(() => invoke($0, `as-block-last`, []), []);
+
+// ./test/core/br.wast:390
+assert_return(() => invoke($0, `as-block-value`, []), [value("i32", 2)]);
+
+// ./test/core/br.wast:392
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 3)]);
+
+// ./test/core/br.wast:393
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 4)]);
+
+// ./test/core/br.wast:394
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 5)]);
+
+// ./test/core/br.wast:396
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:398
+assert_return(() => invoke($0, `as-br_if-cond`, []), []);
+
+// ./test/core/br.wast:399
+assert_return(() => invoke($0, `as-br_if-value`, []), [value("i32", 8)]);
+
+// ./test/core/br.wast:400
+assert_return(() => invoke($0, `as-br_if-value-cond`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:402
+assert_return(() => invoke($0, `as-br_table-index`, []), []);
+
+// ./test/core/br.wast:403
+assert_return(() => invoke($0, `as-br_table-value`, []), [value("i32", 10)]);
+
+// ./test/core/br.wast:404
+assert_return(() => invoke($0, `as-br_table-value-index`, []), [value("i32", 11)]);
+
+// ./test/core/br.wast:406
+assert_return(() => invoke($0, `as-return-value`, []), [value("i64", 7n)]);
+
+// ./test/core/br.wast:407
+assert_return(() => invoke($0, `as-return-values`, []), [value("i32", 2), value("i64", 7n)]);
+
+// ./test/core/br.wast:409
+assert_return(() => invoke($0, `as-if-cond`, []), [value("i32", 2)]);
+
+// ./test/core/br.wast:410
+assert_return(() => invoke($0, `as-if-then`, [1, 6]), [value("i32", 3)]);
+
+// ./test/core/br.wast:411
+assert_return(() => invoke($0, `as-if-then`, [0, 6]), [value("i32", 6)]);
+
+// ./test/core/br.wast:412
+assert_return(() => invoke($0, `as-if-else`, [0, 6]), [value("i32", 4)]);
+
+// ./test/core/br.wast:413
+assert_return(() => invoke($0, `as-if-else`, [1, 6]), [value("i32", 6)]);
+
+// ./test/core/br.wast:415
+assert_return(() => invoke($0, `as-select-first`, [0, 6]), [value("i32", 5)]);
+
+// ./test/core/br.wast:416
+assert_return(() => invoke($0, `as-select-first`, [1, 6]), [value("i32", 5)]);
+
+// ./test/core/br.wast:417
+assert_return(() => invoke($0, `as-select-second`, [0, 6]), [value("i32", 6)]);
+
+// ./test/core/br.wast:418
+assert_return(() => invoke($0, `as-select-second`, [1, 6]), [value("i32", 6)]);
+
+// ./test/core/br.wast:419
+assert_return(() => invoke($0, `as-select-cond`, []), [value("i32", 7)]);
+
+// ./test/core/br.wast:420
+assert_return(() => invoke($0, `as-select-all`, []), [value("i32", 8)]);
+
+// ./test/core/br.wast:422
+assert_return(() => invoke($0, `as-call-first`, []), [value("i32", 12)]);
+
+// ./test/core/br.wast:423
+assert_return(() => invoke($0, `as-call-mid`, []), [value("i32", 13)]);
+
+// ./test/core/br.wast:424
+assert_return(() => invoke($0, `as-call-last`, []), [value("i32", 14)]);
+
+// ./test/core/br.wast:425
+assert_return(() => invoke($0, `as-call-all`, []), [value("i32", 15)]);
+
+// ./test/core/br.wast:427
+assert_return(() => invoke($0, `as-call_indirect-func`, []), [value("i32", 20)]);
+
+// ./test/core/br.wast:428
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 21)]);
+
+// ./test/core/br.wast:429
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 22)]);
+
+// ./test/core/br.wast:430
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 23)]);
+
+// ./test/core/br.wast:431
+assert_return(() => invoke($0, `as-call_indirect-all`, []), [value("i32", 24)]);
+
+// ./test/core/br.wast:433
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("i32", 17)]);
+
+// ./test/core/br.wast:434
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 1)]);
+
+// ./test/core/br.wast:435
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 1)]);
+
+// ./test/core/br.wast:437
+assert_return(() => invoke($0, `as-load-address`, []), [value("f32", 1.7)]);
+
+// ./test/core/br.wast:438
+assert_return(() => invoke($0, `as-loadN-address`, []), [value("i64", 30n)]);
+
+// ./test/core/br.wast:440
+assert_return(() => invoke($0, `as-store-address`, []), [value("i32", 30)]);
+
+// ./test/core/br.wast:441
+assert_return(() => invoke($0, `as-store-value`, []), [value("i32", 31)]);
+
+// ./test/core/br.wast:442
+assert_return(() => invoke($0, `as-store-both`, []), [value("i32", 32)]);
+
+// ./test/core/br.wast:443
+assert_return(() => invoke($0, `as-storeN-address`, []), [value("i32", 32)]);
+
+// ./test/core/br.wast:444
+assert_return(() => invoke($0, `as-storeN-value`, []), [value("i32", 33)]);
+
+// ./test/core/br.wast:445
+assert_return(() => invoke($0, `as-storeN-both`, []), [value("i32", 34)]);
+
+// ./test/core/br.wast:447
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 3.4)]);
+
+// ./test/core/br.wast:449
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 3)]);
+
+// ./test/core/br.wast:450
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i64", 45n)]);
+
+// ./test/core/br.wast:451
+assert_return(() => invoke($0, `as-binary-both`, []), [value("i32", 46)]);
+
+// ./test/core/br.wast:453
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 44)]);
+
+// ./test/core/br.wast:455
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 43)]);
+
+// ./test/core/br.wast:456
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 42)]);
+
+// ./test/core/br.wast:457
+assert_return(() => invoke($0, `as-compare-both`, []), [value("i32", 44)]);
+
+// ./test/core/br.wast:459
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i32", 41)]);
+
+// ./test/core/br.wast:461
+assert_return(() => invoke($0, `as-memory.grow-size`, []), [value("i32", 40)]);
+
+// ./test/core/br.wast:463
+assert_return(() => invoke($0, `nested-block-value`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:464
+assert_return(() => invoke($0, `nested-br-value`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:465
+assert_return(() => invoke($0, `nested-br_if-value`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:466
+assert_return(() => invoke($0, `nested-br_if-value-cond`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:467
+assert_return(() => invoke($0, `nested-br_table-value`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:468
+assert_return(() => invoke($0, `nested-br_table-value-index`, []), [value("i32", 9)]);
+
+// ./test/core/br.wast:470
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-empty-vs-num (result i32)
+    (block (result i32) (br 0) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:477
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-void-vs-num (result i32)
+    (block (result i32) (br 0 (nop)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:483
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:489
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-num-vs-num (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:496
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-br
+      (i32.const 0)
+      (block (result i32) (br 0 (br 0))) (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:505
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-br_if
+      (i32.const 0)
+      (block (result i32) (br_if 0 (br 0) (i32.const 1))) (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:514
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-br_table
+      (i32.const 0)
+      (block (result i32) (br_table 0 (br 0))) (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:523
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-return
+      (block (result i32)
+        (return (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:534
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-select
+      (block (result i32)
+        (select (br 0) (i32.const 1) (i32.const 2))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:545
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-call
+      (block (result i32)
+        (call 1 (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:557
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-arg-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (br 0) (i32.const 0)
+        )
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:573
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-local.set
+      (local i32)
+      (block (result i32)
+        (local.set 0 (br 0)) (local.get 0)
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:585
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-arg-empty-in-local.tee
+      (local i32)
+      (block (result i32)
+        (local.tee 0 (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:597
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-arg-empty-in-global.set
+      (block (result i32)
+        (global.set $$x (br 0)) (global.get $$x)
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:609
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-arg-empty-in-memory.grow
+      (block (result i32)
+        (memory.grow (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:621
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-arg-empty-in-load
+      (block (result i32)
+        (i32.load (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:633
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-arg-empty-in-store
+      (block (result i32)
+        (i32.store (br 0) (i32.const 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br.wast:646
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-label (br 1)))`),
+  `unknown label`,
+);
+
+// ./test/core/br.wast:650
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-nested-label (block (block (br 5)))))`),
+  `unknown label`,
+);
+
+// ./test/core/br.wast:654
+assert_invalid(
+  () => instantiate(`(module (func $$large-label (br 0x10000001)))`),
+  `unknown label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/br_if.wast.js b/js/src/jit-test/tests/wasm/spec/spec/br_if.wast.js
new file mode 100644
index 0000000000..511ee003fb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/br_if.wast.js
@@ -0,0 +1,886 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/br_if.wast
+
+// ./test/core/br_if.wast:3
+let $0 = instantiate(`(module
+  (func $$dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_if 0 (i32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_if 0 (i64.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_if 0 (f32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_if 0 (f64.const 0) (i32.const 1)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_if 0 (f32.const 3) (i32.const 1))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 4) (i32.const 1))))
+  )
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (call $$dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
+    (i32.const 3)
+  )
+  (func (export "as-block-last") (param i32)
+    (block (call $$dummy) (call $$dummy) (br_if 0 (local.get 0)))
+  )
+  (func (export "as-block-first-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11))
+    )
+  )
+  (func (export "as-block-mid-value") (param i32) (result i32)
+    (block (result i32)
+      (call $$dummy)
+      (drop (br_if 0 (i32.const 20) (local.get 0)))
+      (return (i32.const 21))
+    )
+  )
+  (func (export "as-block-last-value") (param i32) (result i32)
+    (block (result i32)
+      (call $$dummy) (call $$dummy) (br_if 0 (i32.const 11) (local.get 0))
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (block (loop (call $$dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
+    (i32.const 4)
+  )
+  (func (export "as-loop-last") (param i32)
+    (loop (call $$dummy) (br_if 1 (local.get 0)))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)))
+      (i32.const 4)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0))))
+      (i32.const 4)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4)
+    )
+  )
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (local.get 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32)
+    (block
+      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $$dummy)))
+    )
+  )
+  (func (export "as-if-else") (param i32 i32)
+    (block
+      (if (local.get 0) (then (call $$dummy)) (else (br_if 1 (local.get 1))))
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (block (result i32)
+      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-select-second") (param i32) (result i32)
+    (block (result i32)
+      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (local.get 0))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 1) (i32.const 2) (br_if 0 (i32.const 3) (i32.const 10)))
+    )
+  )
+
+ (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $$f
+        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $$f
+        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $$f
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (func $$func (param i32 i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (br_if 0 (i32.const 4) (i32.const 10))
+        (i32.const 1) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (i32.const 3) (br_if 0 (i32.const 4) (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (block (result i32)
+      (local.tee 0 (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (block (result i32)
+      (global.set $$a (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result i32)
+    (block (result i32) (i32.load (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (block (result i32) (i32.load8_s (br_if 0 (i32.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (i32.store (br_if 0 (i32.const 30) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i32.store (i32.const 2) (br_if 0 (i32.const 31) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_if 0 (i32.const 32) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i32.store16 (i32.const 2) (br_if 0 (i32.const 33) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
+  )
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (i32.add
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0)))
+            (i32.const 16)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+)`);
+
+// ./test/core/br_if.wast:372
+assert_return(() => invoke($0, `type-i32`, []), []);
+
+// ./test/core/br_if.wast:373
+assert_return(() => invoke($0, `type-i64`, []), []);
+
+// ./test/core/br_if.wast:374
+assert_return(() => invoke($0, `type-f32`, []), []);
+
+// ./test/core/br_if.wast:375
+assert_return(() => invoke($0, `type-f64`, []), []);
+
+// ./test/core/br_if.wast:377
+assert_return(() => invoke($0, `type-i32-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:378
+assert_return(() => invoke($0, `type-i64-value`, []), [value("i64", 2n)]);
+
+// ./test/core/br_if.wast:379
+assert_return(() => invoke($0, `type-f32-value`, []), [value("f32", 3)]);
+
+// ./test/core/br_if.wast:380
+assert_return(() => invoke($0, `type-f64-value`, []), [value("f64", 4)]);
+
+// ./test/core/br_if.wast:382
+assert_return(() => invoke($0, `as-block-first`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:383
+assert_return(() => invoke($0, `as-block-first`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:384
+assert_return(() => invoke($0, `as-block-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:385
+assert_return(() => invoke($0, `as-block-mid`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:386
+assert_return(() => invoke($0, `as-block-last`, [0]), []);
+
+// ./test/core/br_if.wast:387
+assert_return(() => invoke($0, `as-block-last`, [1]), []);
+
+// ./test/core/br_if.wast:389
+assert_return(() => invoke($0, `as-block-first-value`, [0]), [value("i32", 11)]);
+
+// ./test/core/br_if.wast:390
+assert_return(() => invoke($0, `as-block-first-value`, [1]), [value("i32", 10)]);
+
+// ./test/core/br_if.wast:391
+assert_return(() => invoke($0, `as-block-mid-value`, [0]), [value("i32", 21)]);
+
+// ./test/core/br_if.wast:392
+assert_return(() => invoke($0, `as-block-mid-value`, [1]), [value("i32", 20)]);
+
+// ./test/core/br_if.wast:393
+assert_return(() => invoke($0, `as-block-last-value`, [0]), [value("i32", 11)]);
+
+// ./test/core/br_if.wast:394
+assert_return(() => invoke($0, `as-block-last-value`, [1]), [value("i32", 11)]);
+
+// ./test/core/br_if.wast:396
+assert_return(() => invoke($0, `as-loop-first`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:397
+assert_return(() => invoke($0, `as-loop-first`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:398
+assert_return(() => invoke($0, `as-loop-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:399
+assert_return(() => invoke($0, `as-loop-mid`, [1]), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:400
+assert_return(() => invoke($0, `as-loop-last`, [0]), []);
+
+// ./test/core/br_if.wast:401
+assert_return(() => invoke($0, `as-loop-last`, [1]), []);
+
+// ./test/core/br_if.wast:403
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:405
+assert_return(() => invoke($0, `as-br_if-cond`, []), []);
+
+// ./test/core/br_if.wast:406
+assert_return(() => invoke($0, `as-br_if-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:407
+assert_return(() => invoke($0, `as-br_if-value-cond`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:408
+assert_return(() => invoke($0, `as-br_if-value-cond`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:410
+assert_return(() => invoke($0, `as-br_table-index`, []), []);
+
+// ./test/core/br_if.wast:411
+assert_return(() => invoke($0, `as-br_table-value`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:412
+assert_return(() => invoke($0, `as-br_table-value-index`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:414
+assert_return(() => invoke($0, `as-return-value`, []), [value("i64", 1n)]);
+
+// ./test/core/br_if.wast:416
+assert_return(() => invoke($0, `as-if-cond`, [0]), [value("i32", 2)]);
+
+// ./test/core/br_if.wast:417
+assert_return(() => invoke($0, `as-if-cond`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:418
+assert_return(() => invoke($0, `as-if-then`, [0, 0]), []);
+
+// ./test/core/br_if.wast:419
+assert_return(() => invoke($0, `as-if-then`, [4, 0]), []);
+
+// ./test/core/br_if.wast:420
+assert_return(() => invoke($0, `as-if-then`, [0, 1]), []);
+
+// ./test/core/br_if.wast:421
+assert_return(() => invoke($0, `as-if-then`, [4, 1]), []);
+
+// ./test/core/br_if.wast:422
+assert_return(() => invoke($0, `as-if-else`, [0, 0]), []);
+
+// ./test/core/br_if.wast:423
+assert_return(() => invoke($0, `as-if-else`, [3, 0]), []);
+
+// ./test/core/br_if.wast:424
+assert_return(() => invoke($0, `as-if-else`, [0, 1]), []);
+
+// ./test/core/br_if.wast:425
+assert_return(() => invoke($0, `as-if-else`, [3, 1]), []);
+
+// ./test/core/br_if.wast:427
+assert_return(() => invoke($0, `as-select-first`, [0]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:428
+assert_return(() => invoke($0, `as-select-first`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:429
+assert_return(() => invoke($0, `as-select-second`, [0]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:430
+assert_return(() => invoke($0, `as-select-second`, [1]), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:431
+assert_return(() => invoke($0, `as-select-cond`, []), [value("i32", 3)]);
+
+// ./test/core/br_if.wast:433
+assert_return(() => invoke($0, `as-call-first`, []), [value("i32", 12)]);
+
+// ./test/core/br_if.wast:434
+assert_return(() => invoke($0, `as-call-mid`, []), [value("i32", 13)]);
+
+// ./test/core/br_if.wast:435
+assert_return(() => invoke($0, `as-call-last`, []), [value("i32", 14)]);
+
+// ./test/core/br_if.wast:437
+assert_return(() => invoke($0, `as-call_indirect-func`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:438
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:439
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:440
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 4)]);
+
+// ./test/core/br_if.wast:442
+assert_return(() => invoke($0, `as-local.set-value`, [0]), [value("i32", -1)]);
+
+// ./test/core/br_if.wast:443
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 17)]);
+
+// ./test/core/br_if.wast:445
+assert_return(() => invoke($0, `as-local.tee-value`, [0]), [value("i32", -1)]);
+
+// ./test/core/br_if.wast:446
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:448
+assert_return(() => invoke($0, `as-global.set-value`, [0]), [value("i32", -1)]);
+
+// ./test/core/br_if.wast:449
+assert_return(() => invoke($0, `as-global.set-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:451
+assert_return(() => invoke($0, `as-load-address`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:452
+assert_return(() => invoke($0, `as-loadN-address`, []), [value("i32", 30)]);
+
+// ./test/core/br_if.wast:454
+assert_return(() => invoke($0, `as-store-address`, []), [value("i32", 30)]);
+
+// ./test/core/br_if.wast:455
+assert_return(() => invoke($0, `as-store-value`, []), [value("i32", 31)]);
+
+// ./test/core/br_if.wast:456
+assert_return(() => invoke($0, `as-storeN-address`, []), [value("i32", 32)]);
+
+// ./test/core/br_if.wast:457
+assert_return(() => invoke($0, `as-storeN-value`, []), [value("i32", 33)]);
+
+// ./test/core/br_if.wast:459
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f64", 1)]);
+
+// ./test/core/br_if.wast:460
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:461
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:462
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/br_if.wast:463
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:464
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:465
+assert_return(() => invoke($0, `as-memory.grow-size`, []), [value("i32", 1)]);
+
+// ./test/core/br_if.wast:467
+assert_return(() => invoke($0, `nested-block-value`, [0]), [value("i32", 21)]);
+
+// ./test/core/br_if.wast:468
+assert_return(() => invoke($0, `nested-block-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:469
+assert_return(() => invoke($0, `nested-br-value`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:470
+assert_return(() => invoke($0, `nested-br-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:471
+assert_return(() => invoke($0, `nested-br_if-value`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:472
+assert_return(() => invoke($0, `nested-br_if-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:473
+assert_return(() => invoke($0, `nested-br_if-value-cond`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:474
+assert_return(() => invoke($0, `nested-br_if-value-cond`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:475
+assert_return(() => invoke($0, `nested-br_table-value`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:476
+assert_return(() => invoke($0, `nested-br_table-value`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:477
+assert_return(() => invoke($0, `nested-br_table-value-index`, [0]), [value("i32", 5)]);
+
+// ./test/core/br_if.wast:478
+assert_return(() => invoke($0, `nested-br_table-value-index`, [1]), [value("i32", 9)]);
+
+// ./test/core/br_if.wast:480
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-i32 (block (i32.ctz (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:484
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-i64 (block (i64.ctz (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:488
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-f32 (block (f32.neg (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:492
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-f64 (block (f64.neg (br_if 0 (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:497
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-i32 (block (i32.ctz (br_if 0 (i32.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:501
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-i64 (block (i64.ctz (br_if 0 (i64.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:505
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-f32 (block (f32.neg (br_if 0 (f32.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:509
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-f64 (block (f64.neg (br_if 0 (i64.const 1))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:514
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:520
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:526
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:532
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:539
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:545
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:551
+assert_invalid(
+  () => instantiate(`(module (func $$type-false-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:559
+assert_invalid(
+  () => instantiate(`(module (func $$type-true-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:568
+assert_invalid(
+  () => instantiate(`(module (func $$type-cond-empty-vs-i32
+    (block (br_if 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:574
+assert_invalid(
+  () => instantiate(`(module (func $$type-cond-void-vs-i32
+    (block (br_if 0 (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:580
+assert_invalid(
+  () => instantiate(`(module (func $$type-cond-num-vs-i32
+    (block (br_if 0 (i64.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:586
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-cond-void-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:592
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:598
+assert_invalid(
+  () => instantiate(`(module (func $$type-arg-cond-num-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:605
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-1st-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:617
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-2nd-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:629
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-1st-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:640
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-2nd-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/br_if.wast:653
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-label (br_if 1 (i32.const 1))))`),
+  `unknown label`,
+);
+
+// ./test/core/br_if.wast:657
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-nested-label (block (block (br_if 5 (i32.const 1))))))`),
+  `unknown label`,
+);
+
+// ./test/core/br_if.wast:661
+assert_invalid(
+  () => instantiate(`(module (func $$large-label (br_if 0x10000001 (i32.const 1))))`),
+  `unknown label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/bulk.wast.js b/js/src/jit-test/tests/wasm/spec/spec/bulk.wast.js
new file mode 100644
index 0000000000..b0cefa4a73
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/bulk.wast.js
@@ -0,0 +1,499 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/bulk.wast
+
+// ./test/core/bulk.wast:2
+let $0 = instantiate(`(module
+  (memory 1)
+  (data "foo"))`);
+
+// ./test/core/bulk.wast:6
+let $1 = instantiate(`(module
+  (table 3 funcref)
+  (elem funcref (ref.func 0) (ref.null func) (ref.func 1))
+  (func)
+  (func))`);
+
+// ./test/core/bulk.wast:13
+let $2 = instantiate(`(module
+  (memory 1)
+
+  (func (export "fill") (param i32 i32 i32)
+    (memory.fill
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)`);
+
+// ./test/core/bulk.wast:27
+invoke($2, `fill`, [1, 255, 3]);
+
+// ./test/core/bulk.wast:28
+assert_return(() => invoke($2, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:29
+assert_return(() => invoke($2, `load8_u`, [1]), [value("i32", 255)]);
+
+// ./test/core/bulk.wast:30
+assert_return(() => invoke($2, `load8_u`, [2]), [value("i32", 255)]);
+
+// ./test/core/bulk.wast:31
+assert_return(() => invoke($2, `load8_u`, [3]), [value("i32", 255)]);
+
+// ./test/core/bulk.wast:32
+assert_return(() => invoke($2, `load8_u`, [4]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:35
+invoke($2, `fill`, [0, 48042, 2]);
+
+// ./test/core/bulk.wast:36
+assert_return(() => invoke($2, `load8_u`, [0]), [value("i32", 170)]);
+
+// ./test/core/bulk.wast:37
+assert_return(() => invoke($2, `load8_u`, [1]), [value("i32", 170)]);
+
+// ./test/core/bulk.wast:40
+invoke($2, `fill`, [0, 0, 65536]);
+
+// ./test/core/bulk.wast:43
+assert_trap(() => invoke($2, `fill`, [65280, 1, 257]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:45
+assert_return(() => invoke($2, `load8_u`, [65280]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:46
+assert_return(() => invoke($2, `load8_u`, [65535]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:49
+invoke($2, `fill`, [65536, 0, 0]);
+
+// ./test/core/bulk.wast:52
+assert_trap(() => invoke($2, `fill`, [65537, 0, 0]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:57
+let $3 = instantiate(`(module
+  (memory (data "\\aa\\bb\\cc\\dd"))
+
+  (func (export "copy") (param i32 i32 i32)
+    (memory.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)`);
+
+// ./test/core/bulk.wast:71
+invoke($3, `copy`, [10, 0, 4]);
+
+// ./test/core/bulk.wast:73
+assert_return(() => invoke($3, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:74
+assert_return(() => invoke($3, `load8_u`, [10]), [value("i32", 170)]);
+
+// ./test/core/bulk.wast:75
+assert_return(() => invoke($3, `load8_u`, [11]), [value("i32", 187)]);
+
+// ./test/core/bulk.wast:76
+assert_return(() => invoke($3, `load8_u`, [12]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:77
+assert_return(() => invoke($3, `load8_u`, [13]), [value("i32", 221)]);
+
+// ./test/core/bulk.wast:78
+assert_return(() => invoke($3, `load8_u`, [14]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:81
+invoke($3, `copy`, [8, 10, 4]);
+
+// ./test/core/bulk.wast:82
+assert_return(() => invoke($3, `load8_u`, [8]), [value("i32", 170)]);
+
+// ./test/core/bulk.wast:83
+assert_return(() => invoke($3, `load8_u`, [9]), [value("i32", 187)]);
+
+// ./test/core/bulk.wast:84
+assert_return(() => invoke($3, `load8_u`, [10]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:85
+assert_return(() => invoke($3, `load8_u`, [11]), [value("i32", 221)]);
+
+// ./test/core/bulk.wast:86
+assert_return(() => invoke($3, `load8_u`, [12]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:87
+assert_return(() => invoke($3, `load8_u`, [13]), [value("i32", 221)]);
+
+// ./test/core/bulk.wast:90
+invoke($3, `copy`, [10, 7, 6]);
+
+// ./test/core/bulk.wast:91
+assert_return(() => invoke($3, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:92
+assert_return(() => invoke($3, `load8_u`, [11]), [value("i32", 170)]);
+
+// ./test/core/bulk.wast:93
+assert_return(() => invoke($3, `load8_u`, [12]), [value("i32", 187)]);
+
+// ./test/core/bulk.wast:94
+assert_return(() => invoke($3, `load8_u`, [13]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:95
+assert_return(() => invoke($3, `load8_u`, [14]), [value("i32", 221)]);
+
+// ./test/core/bulk.wast:96
+assert_return(() => invoke($3, `load8_u`, [15]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:97
+assert_return(() => invoke($3, `load8_u`, [16]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:100
+invoke($3, `copy`, [65280, 0, 256]);
+
+// ./test/core/bulk.wast:101
+invoke($3, `copy`, [65024, 65280, 256]);
+
+// ./test/core/bulk.wast:104
+invoke($3, `copy`, [65536, 0, 0]);
+
+// ./test/core/bulk.wast:105
+invoke($3, `copy`, [0, 65536, 0]);
+
+// ./test/core/bulk.wast:108
+assert_trap(() => invoke($3, `copy`, [65537, 0, 0]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:110
+assert_trap(() => invoke($3, `copy`, [0, 65537, 0]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:115
+let $4 = instantiate(`(module
+  (memory 1)
+  (data "\\aa\\bb\\cc\\dd")
+
+  (func (export "init") (param i32 i32 i32)
+    (memory.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)`);
+
+// ./test/core/bulk.wast:129
+invoke($4, `init`, [0, 1, 2]);
+
+// ./test/core/bulk.wast:130
+assert_return(() => invoke($4, `load8_u`, [0]), [value("i32", 187)]);
+
+// ./test/core/bulk.wast:131
+assert_return(() => invoke($4, `load8_u`, [1]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:132
+assert_return(() => invoke($4, `load8_u`, [2]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:135
+invoke($4, `init`, [65532, 0, 4]);
+
+// ./test/core/bulk.wast:138
+assert_trap(() => invoke($4, `init`, [65534, 0, 3]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:140
+assert_return(() => invoke($4, `load8_u`, [65534]), [value("i32", 204)]);
+
+// ./test/core/bulk.wast:141
+assert_return(() => invoke($4, `load8_u`, [65535]), [value("i32", 221)]);
+
+// ./test/core/bulk.wast:144
+invoke($4, `init`, [65536, 0, 0]);
+
+// ./test/core/bulk.wast:145
+invoke($4, `init`, [0, 4, 0]);
+
+// ./test/core/bulk.wast:148
+assert_trap(() => invoke($4, `init`, [65537, 0, 0]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:150
+assert_trap(() => invoke($4, `init`, [0, 5, 0]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:154
+let $5 = instantiate(`(module
+  (memory 1)
+  (data $$p "x")
+  (data $$a (memory 0) (i32.const 0) "x")
+
+  (func (export "drop_passive") (data.drop $$p))
+  (func (export "init_passive") (param $$len i32)
+    (memory.init $$p (i32.const 0) (i32.const 0) (local.get $$len)))
+
+  (func (export "drop_active") (data.drop $$a))
+  (func (export "init_active") (param $$len i32)
+    (memory.init $$a (i32.const 0) (i32.const 0) (local.get $$len)))
+)`);
+
+// ./test/core/bulk.wast:168
+invoke($5, `init_passive`, [1]);
+
+// ./test/core/bulk.wast:169
+invoke($5, `drop_passive`, []);
+
+// ./test/core/bulk.wast:170
+invoke($5, `drop_passive`, []);
+
+// ./test/core/bulk.wast:171
+assert_return(() => invoke($5, `init_passive`, [0]), []);
+
+// ./test/core/bulk.wast:172
+assert_trap(() => invoke($5, `init_passive`, [1]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:173
+invoke($5, `init_passive`, [0]);
+
+// ./test/core/bulk.wast:174
+invoke($5, `drop_active`, []);
+
+// ./test/core/bulk.wast:175
+assert_return(() => invoke($5, `init_active`, [0]), []);
+
+// ./test/core/bulk.wast:176
+assert_trap(() => invoke($5, `init_active`, [1]), `out of bounds memory access`);
+
+// ./test/core/bulk.wast:177
+invoke($5, `init_active`, [0]);
+
+// ./test/core/bulk.wast:181
+let $6 = instantiate(`(module
+  ;; 65 data segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "")
+  (func (data.drop 64)))`);
+
+// ./test/core/bulk.wast:196
+let $7 = instantiate(`(module (data "goodbye") (func (data.drop 0)))`);
+
+// ./test/core/bulk.wast:199
+let $8 = instantiate(`(module
+  (table 3 funcref)
+  (elem funcref
+    (ref.func $$zero) (ref.func $$one) (ref.func $$zero) (ref.func $$one))
+
+  (func $$zero (result i32) (i32.const 0))
+  (func $$one (result i32) (i32.const 1))
+
+  (func (export "init") (param i32 i32 i32)
+    (table.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)`);
+
+// ./test/core/bulk.wast:219
+assert_trap(() => invoke($8, `init`, [2, 0, 2]), `out of bounds table access`);
+
+// ./test/core/bulk.wast:221
+assert_trap(() => invoke($8, `call`, [2]), `uninitialized element 2`);
+
+// ./test/core/bulk.wast:224
+invoke($8, `init`, [0, 1, 2]);
+
+// ./test/core/bulk.wast:225
+assert_return(() => invoke($8, `call`, [0]), [value("i32", 1)]);
+
+// ./test/core/bulk.wast:226
+assert_return(() => invoke($8, `call`, [1]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:227
+assert_trap(() => invoke($8, `call`, [2]), `uninitialized element`);
+
+// ./test/core/bulk.wast:230
+invoke($8, `init`, [1, 2, 2]);
+
+// ./test/core/bulk.wast:233
+invoke($8, `init`, [3, 0, 0]);
+
+// ./test/core/bulk.wast:234
+invoke($8, `init`, [0, 4, 0]);
+
+// ./test/core/bulk.wast:237
+assert_trap(() => invoke($8, `init`, [4, 0, 0]), `out of bounds table access`);
+
+// ./test/core/bulk.wast:239
+assert_trap(() => invoke($8, `init`, [0, 5, 0]), `out of bounds table access`);
+
+// ./test/core/bulk.wast:244
+let $9 = instantiate(`(module
+  (table 1 funcref)
+  (func $$f)
+  (elem $$p funcref (ref.func $$f))
+  (elem $$a (table 0) (i32.const 0) func $$f)
+
+  (func (export "drop_passive") (elem.drop $$p))
+  (func (export "init_passive") (param $$len i32)
+    (table.init $$p (i32.const 0) (i32.const 0) (local.get $$len))
+  )
+
+  (func (export "drop_active") (elem.drop $$a))
+  (func (export "init_active") (param $$len i32)
+    (table.init $$a (i32.const 0) (i32.const 0) (local.get $$len))
+  )
+)`);
+
+// ./test/core/bulk.wast:261
+invoke($9, `init_passive`, [1]);
+
+// ./test/core/bulk.wast:262
+invoke($9, `drop_passive`, []);
+
+// ./test/core/bulk.wast:263
+invoke($9, `drop_passive`, []);
+
+// ./test/core/bulk.wast:264
+assert_return(() => invoke($9, `init_passive`, [0]), []);
+
+// ./test/core/bulk.wast:265
+assert_trap(() => invoke($9, `init_passive`, [1]), `out of bounds table access`);
+
+// ./test/core/bulk.wast:266
+invoke($9, `init_passive`, [0]);
+
+// ./test/core/bulk.wast:267
+invoke($9, `drop_active`, []);
+
+// ./test/core/bulk.wast:268
+assert_return(() => invoke($9, `init_active`, [0]), []);
+
+// ./test/core/bulk.wast:269
+assert_trap(() => invoke($9, `init_active`, [1]), `out of bounds table access`);
+
+// ./test/core/bulk.wast:270
+invoke($9, `init_active`, [0]);
+
+// ./test/core/bulk.wast:274
+let $10 = instantiate(`(module
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref)
+  (func (elem.drop 64)))`);
+
+// ./test/core/bulk.wast:297
+let $11 = instantiate(`(module (elem funcref (ref.func 0)) (func (elem.drop 0)))`);
+
+// ./test/core/bulk.wast:300
+let $12 = instantiate(`(module
+  (table 10 funcref)
+  (elem (i32.const 0) $$zero $$one $$two)
+  (func $$zero (result i32) (i32.const 0))
+  (func $$one (result i32) (i32.const 1))
+  (func $$two (result i32) (i32.const 2))
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)`);
+
+// ./test/core/bulk.wast:319
+invoke($12, `copy`, [3, 0, 3]);
+
+// ./test/core/bulk.wast:321
+assert_return(() => invoke($12, `call`, [3]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:322
+assert_return(() => invoke($12, `call`, [4]), [value("i32", 1)]);
+
+// ./test/core/bulk.wast:323
+assert_return(() => invoke($12, `call`, [5]), [value("i32", 2)]);
+
+// ./test/core/bulk.wast:326
+invoke($12, `copy`, [0, 1, 3]);
+
+// ./test/core/bulk.wast:328
+assert_return(() => invoke($12, `call`, [0]), [value("i32", 1)]);
+
+// ./test/core/bulk.wast:329
+assert_return(() => invoke($12, `call`, [1]), [value("i32", 2)]);
+
+// ./test/core/bulk.wast:330
+assert_return(() => invoke($12, `call`, [2]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:333
+invoke($12, `copy`, [2, 0, 3]);
+
+// ./test/core/bulk.wast:335
+assert_return(() => invoke($12, `call`, [2]), [value("i32", 1)]);
+
+// ./test/core/bulk.wast:336
+assert_return(() => invoke($12, `call`, [3]), [value("i32", 2)]);
+
+// ./test/core/bulk.wast:337
+assert_return(() => invoke($12, `call`, [4]), [value("i32", 0)]);
+
+// ./test/core/bulk.wast:340
+invoke($12, `copy`, [6, 8, 2]);
+
+// ./test/core/bulk.wast:341
+invoke($12, `copy`, [8, 6, 2]);
+
+// ./test/core/bulk.wast:344
+invoke($12, `copy`, [10, 0, 0]);
+
+// ./test/core/bulk.wast:345
+invoke($12, `copy`, [0, 10, 0]);
+
+// ./test/core/bulk.wast:348
+assert_trap(() => invoke($12, `copy`, [11, 0, 0]), `out of bounds table access`);
+
+// ./test/core/bulk.wast:350
+assert_trap(() => invoke($12, `copy`, [0, 11, 0]), `out of bounds table access`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/call.wast.js b/js/src/jit-test/tests/wasm/spec/spec/call.wast.js
new file mode 100644
index 0000000000..4595cf4df0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/call.wast.js
@@ -0,0 +1,683 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/call.wast
+
+// ./test/core/call.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definitions
+  (func $$const-i32 (result i32) (i32.const 0x132))
+  (func $$const-i64 (result i64) (i64.const 0x164))
+  (func $$const-f32 (result f32) (f32.const 0xf32))
+  (func $$const-f64 (result f64) (f64.const 0xf64))
+  (func $$const-i32-i64 (result i32 i64) (i32.const 0x132) (i64.const 0x164))
+
+  (func $$id-i32 (param i32) (result i32) (local.get 0))
+  (func $$id-i64 (param i64) (result i64) (local.get 0))
+  (func $$id-f32 (param f32) (result f32) (local.get 0))
+  (func $$id-f64 (param f64) (result f64) (local.get 0))
+  (func $$id-i32-f64 (param i32 f64) (result i32 f64)
+    (local.get 0) (local.get 1)
+  )
+
+  (func $$swap-i32-i32 (param i32 i32) (result i32 i32)
+    (local.get 1) (local.get 0)
+  )
+  (func $$swap-f32-f64 (param f32 f64) (result f64 f32)
+    (local.get 1) (local.get 0)
+  )
+  (func $$swap-f64-i32 (param f64 i32) (result i32 f64)
+    (local.get 1) (local.get 0)
+  )
+
+  (func $$f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $$i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $$f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $$i64-f64 (param i64 f64) (result f64) (local.get 1))
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32) (call $$const-i32))
+  (func (export "type-i64") (result i64) (call $$const-i64))
+  (func (export "type-f32") (result f32) (call $$const-f32))
+  (func (export "type-f64") (result f64) (call $$const-f64))
+  (func (export "type-i32-i64") (result i32 i64) (call $$const-i32-i64))
+
+  (func (export "type-first-i32") (result i32) (call $$id-i32 (i32.const 32)))
+  (func (export "type-first-i64") (result i64) (call $$id-i64 (i64.const 64)))
+  (func (export "type-first-f32") (result f32) (call $$id-f32 (f32.const 1.32)))
+  (func (export "type-first-f64") (result f64) (call $$id-f64 (f64.const 1.64)))
+
+  (func (export "type-second-i32") (result i32)
+    (call $$f32-i32 (f32.const 32.1) (i32.const 32))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call $$i32-i64 (i32.const 32) (i64.const 64))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call $$f64-f32 (f64.const 64) (f32.const 32))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call $$i64-f64 (i64.const 64) (f64.const 64.1))
+  )
+
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call $$id-i32-f64 (i32.const 32) (f64.const 1.64))
+  )
+  (func (export "type-all-i32-i32") (result i32 i32)
+    (call $$swap-i32-i32 (i32.const 1) (i32.const 2))
+  )
+  (func (export "type-all-f32-f64") (result f64 f32)
+    (call $$swap-f32-f64 (f32.const 1) (f64.const 2))
+  )
+  (func (export "type-all-f64-i32") (result i32 f64)
+    (call $$swap-f64-i32 (f64.const 1) (i32.const 2))
+  )
+
+  ;; Composition
+
+  (func (export "as-binary-all-operands") (result i32)
+    (i32.add (call $$swap-i32-i32 (i32.const 3) (i32.const 4)))
+  )
+
+  (func (export "as-mixed-operands") (result i32)
+    (call $$swap-i32-i32 (i32.const 3) (i32.const 4))
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "as-call-all-operands") (result i32 i32)
+    (call $$swap-i32-i32 (call $$swap-i32-i32 (i32.const 3) (i32.const 4)))
+  )
+
+  ;; Recursion
+
+  (func $$fac (export "fac") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call $$fac (i64.sub (local.get 0) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  (func $$fac-acc (export "fac-acc") (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (call $$fac-acc
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+        )
+      )
+    )
+  )
+
+  (func $$fib (export "fib") (param i64) (result i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call $$fib (i64.sub (local.get 0) (i64.const 2)))
+          (call $$fib (i64.sub (local.get 0) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  (func $$even (export "even") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 44))
+      (else (call $$odd (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+  (func $$odd (export "odd") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 99))
+      (else (call $$even (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $$runaway (export "runaway") (call $$runaway))
+
+  (func $$mutual-runaway1 (export "mutual-runaway") (call $$mutual-runaway2))
+  (func $$mutual-runaway2 (call $$mutual-runaway1))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call $$const-i32) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call $$const-i32) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call $$const-i32))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call $$const-i32) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (call $$const-i32) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call $$const-i32)))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (call $$const-i32) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call $$const-i32) (br_table 0 0))
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (call $$const-i32) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (call $$const-i32) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (call $$const-i32)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (call $$const-i32) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call $$const-i32) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call $$const-i32))
+  )
+  (func (export "as-return-value") (result i32)
+    (call $$const-i32) (return)
+  )
+  (func (export "as-drop-operand")
+    (call $$const-i32) (drop)
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (call $$const-i32)))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (call $$const-i32)) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (call $$const-i32))
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$a (call $$const-i32))
+    (global.get $$a)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call $$const-i32))
+  )
+
+  (func $$dummy (param i32) (result i32) (local.get 0))
+  (func $$du (param f32) (result f32) (local.get 0))
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.sqrt (call $$du (f32.const 0x0p+0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (call $$dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (call $$dummy (i32.const 1))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (call $$dummy (i32.const 1))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (call $$dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (call $$dummy (i32.const 1))))
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64) (i64.extend_i32_s (call $$dummy (i32.const 1))))
+  )
+
+  ;; Test correct argument passing
+
+  (func $$return-from-long-argument-list-helper (param f32 i32 i32 f64 f32 f32 f32 f64 f32 i32 i32 f32 f64 i64 i64 i32 i64 i64 f32 i64 i64 i64 i32 f32 f32 f32 f64 f32 i32 i64 f32 f64 f64 f32 i32 f32 f32 f64 i64 f64 i32 i64 f32 f64 i32 i32 i32 i64 f64 i32 i64 i64 f64 f64 f64 f64 f64 f64 i32 f32 f64 f64 i32 i64 f32 f32 f32 i32 f64 f64 f64 f64 f64 f32 i64 i64 i32 i32 i32 f32 f64 i32 i64 f32 f32 f32 i32 i32 f32 f64 i64 f32 f64 f32 f32 f32 i32 f32 i64 i32) (result i32)
+    (local.get 99)
+  )
+
+  (func (export "return-from-long-argument-list") (param i32) (result i32)
+    (call $$return-from-long-argument-list-helper (f32.const 0) (i32.const 0) (i32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (i64.const 0) (local.get 0))
+  )
+)`);
+
+// ./test/core/call.wast:285
+assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:286
+assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]);
+
+// ./test/core/call.wast:287
+assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]);
+
+// ./test/core/call.wast:288
+assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]);
+
+// ./test/core/call.wast:289
+assert_return(() => invoke($0, `type-i32-i64`, []), [value("i32", 306), value("i64", 356n)]);
+
+// ./test/core/call.wast:291
+assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call.wast:292
+assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call.wast:293
+assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]);
+
+// ./test/core/call.wast:294
+assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]);
+
+// ./test/core/call.wast:296
+assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call.wast:297
+assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call.wast:298
+assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]);
+
+// ./test/core/call.wast:299
+assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]);
+
+// ./test/core/call.wast:301
+assert_return(() => invoke($0, `type-all-i32-f64`, []), [value("i32", 32), value("f64", 1.64)]);
+
+// ./test/core/call.wast:302
+assert_return(() => invoke($0, `type-all-i32-i32`, []), [value("i32", 2), value("i32", 1)]);
+
+// ./test/core/call.wast:303
+assert_return(() => invoke($0, `type-all-f32-f64`, []), [value("f64", 2), value("f32", 1)]);
+
+// ./test/core/call.wast:304
+assert_return(() => invoke($0, `type-all-f64-i32`, []), [value("i32", 2), value("f64", 1)]);
+
+// ./test/core/call.wast:306
+assert_return(() => invoke($0, `as-binary-all-operands`, []), [value("i32", 7)]);
+
+// ./test/core/call.wast:307
+assert_return(() => invoke($0, `as-mixed-operands`, []), [value("i32", 32)]);
+
+// ./test/core/call.wast:308
+assert_return(() => invoke($0, `as-call-all-operands`, []), [value("i32", 3), value("i32", 4)]);
+
+// ./test/core/call.wast:310
+assert_return(() => invoke($0, `fac`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call.wast:311
+assert_return(() => invoke($0, `fac`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call.wast:312
+assert_return(() => invoke($0, `fac`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/call.wast:313
+assert_return(() => invoke($0, `fac`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/call.wast:314
+assert_return(() => invoke($0, `fac-acc`, [0n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/call.wast:315
+assert_return(() => invoke($0, `fac-acc`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/call.wast:316
+assert_return(() => invoke($0, `fac-acc`, [5n, 1n]), [value("i64", 120n)]);
+
+// ./test/core/call.wast:317
+assert_return(() => invoke($0, `fac-acc`, [25n, 1n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/call.wast:322
+assert_return(() => invoke($0, `fib`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call.wast:323
+assert_return(() => invoke($0, `fib`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call.wast:324
+assert_return(() => invoke($0, `fib`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/call.wast:325
+assert_return(() => invoke($0, `fib`, [5n]), [value("i64", 8n)]);
+
+// ./test/core/call.wast:326
+assert_return(() => invoke($0, `fib`, [20n]), [value("i64", 10946n)]);
+
+// ./test/core/call.wast:328
+assert_return(() => invoke($0, `even`, [0n]), [value("i32", 44)]);
+
+// ./test/core/call.wast:329
+assert_return(() => invoke($0, `even`, [1n]), [value("i32", 99)]);
+
+// ./test/core/call.wast:330
+assert_return(() => invoke($0, `even`, [100n]), [value("i32", 44)]);
+
+// ./test/core/call.wast:331
+assert_return(() => invoke($0, `even`, [77n]), [value("i32", 99)]);
+
+// ./test/core/call.wast:332
+assert_return(() => invoke($0, `odd`, [0n]), [value("i32", 99)]);
+
+// ./test/core/call.wast:333
+assert_return(() => invoke($0, `odd`, [1n]), [value("i32", 44)]);
+
+// ./test/core/call.wast:334
+assert_return(() => invoke($0, `odd`, [200n]), [value("i32", 99)]);
+
+// ./test/core/call.wast:335
+assert_return(() => invoke($0, `odd`, [77n]), [value("i32", 44)]);
+
+// ./test/core/call.wast:337
+assert_exhaustion(() => invoke($0, `runaway`, []), `call stack exhausted`);
+
+// ./test/core/call.wast:338
+assert_exhaustion(() => invoke($0, `mutual-runaway`, []), `call stack exhausted`);
+
+// ./test/core/call.wast:340
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:341
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/call.wast:342
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/call.wast:344
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 1)]);
+
+// ./test/core/call.wast:346
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:347
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/call.wast:349
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:350
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/call.wast:352
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:353
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 2)]);
+
+// ./test/core/call.wast:354
+assert_trap(() => invoke($0, `as-call_indirect-last`, []), `undefined element`);
+
+// ./test/core/call.wast:356
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/call.wast:357
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/call.wast:359
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/call.wast:360
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:361
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/call.wast:362
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:363
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:364
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:365
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 306)]);
+
+// ./test/core/call.wast:366
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/call.wast:368
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 0)]);
+
+// ./test/core/call.wast:369
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 11)]);
+
+// ./test/core/call.wast:370
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 9)]);
+
+// ./test/core/call.wast:371
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/call.wast:372
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/call.wast:373
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/call.wast:374
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i64", 1n)]);
+
+// ./test/core/call.wast:376
+assert_return(() => invoke($0, `return-from-long-argument-list`, [42]), [value("i32", 42)]);
+
+// ./test/core/call.wast:380
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-void-vs-num (i32.eqz (call 1)))
+    (func)
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:387
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-num-vs-num (i32.eqz (call 1)))
+    (func (result i64) (i64.const 1))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:395
+assert_invalid(
+  () => instantiate(`(module
+    (func $$arity-0-vs-1 (call 1))
+    (func (param i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:402
+assert_invalid(
+  () => instantiate(`(module
+    (func $$arity-0-vs-2 (call 1))
+    (func (param f64 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:409
+assert_invalid(
+  () => instantiate(`(module
+    (func $$arity-1-vs-0 (call 1 (i32.const 1)))
+    (func)
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:416
+assert_invalid(
+  () => instantiate(`(module
+    (func $$arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1)))
+    (func)
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:424
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-void-vs-num (call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:431
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-void-vs-num (call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:438
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:445
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:453
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-empty-in-block
+      (block (call 1))
+    )
+    (func (param i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:462
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-empty-in-block
+      (block (call 1 (i32.const 0)))
+    )
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:471
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-empty-in-loop
+      (loop (call 1))
+    )
+    (func (param i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:480
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-empty-in-loop
+      (loop (call 1 (i32.const 0)))
+    )
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:489
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-first-empty-in-then
+      (if (i32.const 0) (then (call 1)))
+    )
+    (func (param i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:498
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-second-empty-in-then
+      (if (i32.const 0) (then (call 1 (i32.const 0))))
+    )
+    (func (param i32 i32))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call.wast:511
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-func (call 1)))`),
+  `unknown function`,
+);
+
+// ./test/core/call.wast:515
+assert_invalid(
+  () => instantiate(`(module (func $$large-func (call 1012321300)))`),
+  `unknown function`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/call_indirect.wast.js b/js/src/jit-test/tests/wasm/spec/spec/call_indirect.wast.js
new file mode 100644
index 0000000000..9d62c42427
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/call_indirect.wast.js
@@ -0,0 +1,1256 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/call_indirect.wast
+
+// ./test/core/call_indirect.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definitions
+  (type $$proc (func))
+  (type $$out-i32 (func (result i32)))
+  (type $$out-i64 (func (result i64)))
+  (type $$out-f32 (func (result f32)))
+  (type $$out-f64 (func (result f64)))
+  (type $$out-f64-i32 (func (result f64 i32)))
+  (type $$over-i32 (func (param i32) (result i32)))
+  (type $$over-i64 (func (param i64) (result i64)))
+  (type $$over-f32 (func (param f32) (result f32)))
+  (type $$over-f64 (func (param f64) (result f64)))
+  (type $$over-i32-f64 (func (param i32 f64) (result i32 f64)))
+  (type $$swap-i32-i64 (func (param i32 i64) (result i64 i32)))
+  (type $$f32-i32 (func (param f32 i32) (result i32)))
+  (type $$i32-i64 (func (param i32 i64) (result i64)))
+  (type $$f64-f32 (func (param f64 f32) (result f32)))
+  (type $$i64-f64 (func (param i64 f64) (result f64)))
+  (type $$over-i32-duplicate (func (param i32) (result i32)))
+  (type $$over-i64-duplicate (func (param i64) (result i64)))
+  (type $$over-f32-duplicate (func (param f32) (result f32)))
+  (type $$over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $$const-i32 (type $$out-i32) (i32.const 0x132))
+  (func $$const-i64 (type $$out-i64) (i64.const 0x164))
+  (func $$const-f32 (type $$out-f32) (f32.const 0xf32))
+  (func $$const-f64 (type $$out-f64) (f64.const 0xf64))
+  (func $$const-f64-i32 (type $$out-f64-i32) (f64.const 0xf64) (i32.const 32))
+
+  (func $$id-i32 (type $$over-i32) (local.get 0))
+  (func $$id-i64 (type $$over-i64) (local.get 0))
+  (func $$id-f32 (type $$over-f32) (local.get 0))
+  (func $$id-f64 (type $$over-f64) (local.get 0))
+  (func $$id-i32-f64 (type $$over-i32-f64) (local.get 0) (local.get 1))
+  (func $$swap-i32-i64 (type $$swap-i32-i64) (local.get 1) (local.get 0))
+
+  (func $$i32-i64 (type $$i32-i64) (local.get 1))
+  (func $$i64-f64 (type $$i64-f64) (local.get 1))
+  (func $$f32-i32 (type $$f32-i32) (local.get 1))
+  (func $$f64-f32 (type $$f64-f32) (local.get 1))
+
+  (func $$over-i32-duplicate (type $$over-i32-duplicate) (local.get 0))
+  (func $$over-i64-duplicate (type $$over-i64-duplicate) (local.get 0))
+  (func $$over-f32-duplicate (type $$over-f32-duplicate) (local.get 0))
+  (func $$over-f64-duplicate (type $$over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $$const-i32 $$const-i64 $$const-f32 $$const-f64  ;; 0..3
+      $$id-i32 $$id-i64 $$id-f32 $$id-f64              ;; 4..7
+      $$f32-i32 $$i32-i64 $$f64-f32 $$i64-f64          ;; 9..11
+      $$fac-i64 $$fib-i64 $$even $$odd                 ;; 12..15
+      $$runaway $$mutual-runaway1 $$mutual-runaway2   ;; 16..18
+      $$over-i32-duplicate $$over-i64-duplicate      ;; 19..20
+      $$over-f32-duplicate $$over-f64-duplicate      ;; 21..22
+      $$fac-i32 $$fac-f32 $$fac-f64                   ;; 23..25
+      $$fib-i32 $$fib-f32 $$fib-f64                   ;; 26..28
+      $$const-f64-i32 $$id-i32-f64 $$swap-i32-i64     ;; 29..31
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (call_indirect (i32.const 0))
+    (call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (call_indirect (result) (i32.const 0))
+    (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+    (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+    (drop (i32.eqz
+      (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    ))
+    (drop (i32.eqz
+      (call_indirect
+        (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+        (result) (result i32) (result) (result)
+        (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+      )
+    ))
+    (drop (i64.eqz
+      (call_indirect (type $$over-i64) (param i64) (result i64)
+        (i64.const 0) (i32.const 0)
+      )
+    ))
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (call_indirect (type $$out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (call_indirect (type $$out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (call_indirect (type $$out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (call_indirect (type $$out-f64) (i32.const 3))
+  )
+  (func (export "type-f64-i32") (result f64 i32)
+    (call_indirect (type $$out-f64-i32) (i32.const 29))
+  )
+
+  (func (export "type-index") (result i64)
+    (call_indirect (type $$over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (call_indirect (type $$over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (call_indirect (type $$over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (call_indirect (type $$over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (call_indirect (type $$over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (call_indirect (type $$f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call_indirect (type $$i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call_indirect (type $$f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call_indirect (type $$i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
+  )
+
+  (func (export "type-all-f64-i32") (result f64 i32)
+    (call_indirect (type $$out-f64-i32) (i32.const 29))
+  )
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call_indirect (type $$over-i32-f64)
+      (i32.const 1) (f64.const 2) (i32.const 30)
+    )
+  )
+  (func (export "type-all-i32-i64") (result i64 i32)
+    (call_indirect (type $$swap-i32-i64)
+      (i32.const 1) (i64.const 2) (i32.const 31)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (call_indirect (type $$over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural-i64") (param i32) (result i64)
+    (call_indirect (type $$over-i64-duplicate) (i64.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-i32") (param i32) (result i32)
+    (call_indirect (type $$over-i32-duplicate) (i32.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-f32") (param i32) (result f32)
+    (call_indirect (type $$over-f32-duplicate) (f32.const 9.0) (local.get 0))
+  )
+  (func (export "dispatch-structural-f64") (param i32) (result f64)
+    (call_indirect (type $$over-f64-duplicate) (f64.const 9.0) (local.get 0))
+  )
+
+  ;; Recursion
+
+  (func $$fac-i64 (export "fac-i64") (type $$over-i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 12)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-i64 (export "fib-i64") (type $$over-i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 2))
+            (i32.const 13)
+          )
+          (call_indirect (type $$over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 13)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-i32 (export "fac-i32") (type $$over-i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 1))
+      (else
+        (i32.mul
+          (local.get 0)
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-f32 (export "fac-f32") (type $$over-f32)
+    (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.mul
+          (local.get 0)
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 24)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fac-f64 (export "fac-f64") (type $$over-f64)
+    (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.mul
+          (local.get 0)
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 25)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-i32 (export "fib-i32") (type $$over-i32)
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 2))
+            (i32.const 26)
+          )
+          (call_indirect (type $$over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 26)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-f32 (export "fib-f32") (type $$over-f32)
+    (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.add
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 2.0))
+            (i32.const 27)
+          )
+          (call_indirect (type $$over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 27)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$fib-f64 (export "fib-f64") (type $$over-f64)
+    (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.add
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 2.0))
+            (i32.const 28)
+          )
+          (call_indirect (type $$over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 28)
+          )
+        )
+      )
+    )
+  )
+
+  (func $$even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (call_indirect (type $$over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $$odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (call_indirect (type $$over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $$runaway (export "runaway") (call_indirect (type $$proc) (i32.const 16)))
+
+  (func $$mutual-runaway1 (export "mutual-runaway") (call_indirect (type $$proc) (i32.const 18)))
+  (func $$mutual-runaway2 (call_indirect (type $$proc) (i32.const 17)))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call_indirect (type $$out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i64)
+    (block (result i64) (br_if 0 (call_indirect (type $$out-i64) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0))))
+  )
+
+  (func (export "as-br_table-first") (result f32)
+    (block (result f32) (call_indirect (type $$out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call_indirect (type $$out-i32) (i32.const 0)) (br_table 0 0))
+  )
+
+  (func (export "as-store-first")
+    (call_indirect (type $$out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call_indirect (type $$out-f64) (i32.const 3)) (f64.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+  (func (export "as-return-value") (result i32)
+    (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4)) (return)
+  )
+  (func (export "as-drop-operand")
+    (call_indirect (type $$over-i64) (i64.const 1) (i32.const 5)) (drop)
+  )
+  (func (export "as-br-value") (result f32)
+    (block (result f32) (br 0 (call_indirect (type $$over-f32) (f32.const 1) (i32.const 6))))
+  )
+  (func (export "as-local.set-value") (result f64)
+    (local f64) (local.set 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result f64)
+    (local f64) (local.tee 0 (call_indirect (type $$over-f64) (f64.const 1) (i32.const 7)))
+  )
+  (global $$a (mut f64) (f64.const 10.0))
+  (func (export "as-global.set-value") (result f64)
+    (global.set $$a (call_indirect (type $$over-f64) (f64.const 1.0) (i32.const 7)))
+    (global.get $$a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call_indirect (type $$out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32)
+      (f32.sqrt
+        (call_indirect (type $$over-f32) (f32.const 0x0p+0) (i32.const 6))
+      )
+    )
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32)
+      (i32.sub
+        (i32.const 10)
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32)
+      (i32.eqz
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (i32.le_u
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (i32.ne
+        (i32.const 10)
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64)
+      (i64.extend_i32_s
+        (call_indirect (type $$over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+)`);
+
+// ./test/core/call_indirect.wast:471
+assert_return(() => invoke($0, `type-i32`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:472
+assert_return(() => invoke($0, `type-i64`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:473
+assert_return(() => invoke($0, `type-f32`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:474
+assert_return(() => invoke($0, `type-f64`, []), [value("f64", 3940)]);
+
+// ./test/core/call_indirect.wast:475
+assert_return(() => invoke($0, `type-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:477
+assert_return(() => invoke($0, `type-index`, []), [value("i64", 100n)]);
+
+// ./test/core/call_indirect.wast:479
+assert_return(() => invoke($0, `type-first-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:480
+assert_return(() => invoke($0, `type-first-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:481
+assert_return(() => invoke($0, `type-first-f32`, []), [value("f32", 1.32)]);
+
+// ./test/core/call_indirect.wast:482
+assert_return(() => invoke($0, `type-first-f64`, []), [value("f64", 1.64)]);
+
+// ./test/core/call_indirect.wast:484
+assert_return(() => invoke($0, `type-second-i32`, []), [value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:485
+assert_return(() => invoke($0, `type-second-i64`, []), [value("i64", 64n)]);
+
+// ./test/core/call_indirect.wast:486
+assert_return(() => invoke($0, `type-second-f32`, []), [value("f32", 32)]);
+
+// ./test/core/call_indirect.wast:487
+assert_return(() => invoke($0, `type-second-f64`, []), [value("f64", 64.1)]);
+
+// ./test/core/call_indirect.wast:489
+assert_return(() => invoke($0, `type-all-f64-i32`, []), [value("f64", 3940), value("i32", 32)]);
+
+// ./test/core/call_indirect.wast:490
+assert_return(() => invoke($0, `type-all-i32-f64`, []), [value("i32", 1), value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:491
+assert_return(() => invoke($0, `type-all-i32-i64`, []), [value("i64", 2n), value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:493
+assert_return(() => invoke($0, `dispatch`, [5, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:494
+assert_return(() => invoke($0, `dispatch`, [5, 5n]), [value("i64", 5n)]);
+
+// ./test/core/call_indirect.wast:495
+assert_return(() => invoke($0, `dispatch`, [12, 5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:496
+assert_return(() => invoke($0, `dispatch`, [13, 5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:497
+assert_return(() => invoke($0, `dispatch`, [20, 2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:498
+assert_trap(() => invoke($0, `dispatch`, [0, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:499
+assert_trap(() => invoke($0, `dispatch`, [15, 2n]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:500
+assert_trap(() => invoke($0, `dispatch`, [32, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:501
+assert_trap(() => invoke($0, `dispatch`, [-1, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:502
+assert_trap(() => invoke($0, `dispatch`, [1213432423, 2n]), `undefined element`);
+
+// ./test/core/call_indirect.wast:504
+assert_return(() => invoke($0, `dispatch-structural-i64`, [5]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:505
+assert_return(() => invoke($0, `dispatch-structural-i64`, [12]), [value("i64", 362880n)]);
+
+// ./test/core/call_indirect.wast:506
+assert_return(() => invoke($0, `dispatch-structural-i64`, [13]), [value("i64", 55n)]);
+
+// ./test/core/call_indirect.wast:507
+assert_return(() => invoke($0, `dispatch-structural-i64`, [20]), [value("i64", 9n)]);
+
+// ./test/core/call_indirect.wast:508
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [11]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:509
+assert_trap(() => invoke($0, `dispatch-structural-i64`, [22]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:511
+assert_return(() => invoke($0, `dispatch-structural-i32`, [4]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:512
+assert_return(() => invoke($0, `dispatch-structural-i32`, [23]), [value("i32", 362880)]);
+
+// ./test/core/call_indirect.wast:513
+assert_return(() => invoke($0, `dispatch-structural-i32`, [26]), [value("i32", 55)]);
+
+// ./test/core/call_indirect.wast:514
+assert_return(() => invoke($0, `dispatch-structural-i32`, [19]), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:515
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [9]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:516
+assert_trap(() => invoke($0, `dispatch-structural-i32`, [21]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:518
+assert_return(() => invoke($0, `dispatch-structural-f32`, [6]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:519
+assert_return(() => invoke($0, `dispatch-structural-f32`, [24]), [value("f32", 362880)]);
+
+// ./test/core/call_indirect.wast:520
+assert_return(() => invoke($0, `dispatch-structural-f32`, [27]), [value("f32", 55)]);
+
+// ./test/core/call_indirect.wast:521
+assert_return(() => invoke($0, `dispatch-structural-f32`, [21]), [value("f32", 9)]);
+
+// ./test/core/call_indirect.wast:522
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [8]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:523
+assert_trap(() => invoke($0, `dispatch-structural-f32`, [19]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:525
+assert_return(() => invoke($0, `dispatch-structural-f64`, [7]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:526
+assert_return(() => invoke($0, `dispatch-structural-f64`, [25]), [value("f64", 362880)]);
+
+// ./test/core/call_indirect.wast:527
+assert_return(() => invoke($0, `dispatch-structural-f64`, [28]), [value("f64", 55)]);
+
+// ./test/core/call_indirect.wast:528
+assert_return(() => invoke($0, `dispatch-structural-f64`, [22]), [value("f64", 9)]);
+
+// ./test/core/call_indirect.wast:529
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [10]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:530
+assert_trap(() => invoke($0, `dispatch-structural-f64`, [18]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:532
+assert_return(() => invoke($0, `fac-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:533
+assert_return(() => invoke($0, `fac-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:534
+assert_return(() => invoke($0, `fac-i64`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/call_indirect.wast:535
+assert_return(() => invoke($0, `fac-i64`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/call_indirect.wast:537
+assert_return(() => invoke($0, `fac-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:538
+assert_return(() => invoke($0, `fac-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:539
+assert_return(() => invoke($0, `fac-i32`, [5]), [value("i32", 120)]);
+
+// ./test/core/call_indirect.wast:540
+assert_return(() => invoke($0, `fac-i32`, [10]), [value("i32", 3628800)]);
+
+// ./test/core/call_indirect.wast:542
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:543
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:544
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 5)]), [value("f32", 120)]);
+
+// ./test/core/call_indirect.wast:545
+assert_return(() => invoke($0, `fac-f32`, [value("f32", 10)]), [value("f32", 3628800)]);
+
+// ./test/core/call_indirect.wast:547
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:548
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:549
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 5)]), [value("f64", 120)]);
+
+// ./test/core/call_indirect.wast:550
+assert_return(() => invoke($0, `fac-f64`, [value("f64", 10)]), [value("f64", 3628800)]);
+
+// ./test/core/call_indirect.wast:552
+assert_return(() => invoke($0, `fib-i64`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:553
+assert_return(() => invoke($0, `fib-i64`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:554
+assert_return(() => invoke($0, `fib-i64`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/call_indirect.wast:555
+assert_return(() => invoke($0, `fib-i64`, [5n]), [value("i64", 8n)]);
+
+// ./test/core/call_indirect.wast:556
+assert_return(() => invoke($0, `fib-i64`, [20n]), [value("i64", 10946n)]);
+
+// ./test/core/call_indirect.wast:558
+assert_return(() => invoke($0, `fib-i32`, [0]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:559
+assert_return(() => invoke($0, `fib-i32`, [1]), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:560
+assert_return(() => invoke($0, `fib-i32`, [2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:561
+assert_return(() => invoke($0, `fib-i32`, [5]), [value("i32", 8)]);
+
+// ./test/core/call_indirect.wast:562
+assert_return(() => invoke($0, `fib-i32`, [20]), [value("i32", 10946)]);
+
+// ./test/core/call_indirect.wast:564
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:565
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:566
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 2)]), [value("f32", 2)]);
+
+// ./test/core/call_indirect.wast:567
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 5)]), [value("f32", 8)]);
+
+// ./test/core/call_indirect.wast:568
+assert_return(() => invoke($0, `fib-f32`, [value("f32", 20)]), [value("f32", 10946)]);
+
+// ./test/core/call_indirect.wast:570
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:571
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:572
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 2)]), [value("f64", 2)]);
+
+// ./test/core/call_indirect.wast:573
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 5)]), [value("f64", 8)]);
+
+// ./test/core/call_indirect.wast:574
+assert_return(() => invoke($0, `fib-f64`, [value("f64", 20)]), [value("f64", 10946)]);
+
+// ./test/core/call_indirect.wast:576
+assert_return(() => invoke($0, `even`, [0]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:577
+assert_return(() => invoke($0, `even`, [1]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:578
+assert_return(() => invoke($0, `even`, [100]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:579
+assert_return(() => invoke($0, `even`, [77]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:580
+assert_return(() => invoke($0, `odd`, [0]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:581
+assert_return(() => invoke($0, `odd`, [1]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:582
+assert_return(() => invoke($0, `odd`, [200]), [value("i32", 99)]);
+
+// ./test/core/call_indirect.wast:583
+assert_return(() => invoke($0, `odd`, [77]), [value("i32", 44)]);
+
+// ./test/core/call_indirect.wast:585
+assert_exhaustion(() => invoke($0, `runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:586
+assert_exhaustion(() => invoke($0, `mutual-runaway`, []), `call stack exhausted`);
+
+// ./test/core/call_indirect.wast:588
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 306)]);
+
+// ./test/core/call_indirect.wast:589
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:590
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:592
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:594
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i64", 356n)]);
+
+// ./test/core/call_indirect.wast:595
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:597
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("f32", 3890)]);
+
+// ./test/core/call_indirect.wast:598
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:600
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/call_indirect.wast:601
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/call_indirect.wast:603
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:604
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:605
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/call_indirect.wast:606
+assert_return(() => invoke($0, `as-br-value`, []), [value("f32", 1)]);
+
+// ./test/core/call_indirect.wast:607
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:608
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:609
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("f64", 1)]);
+
+// ./test/core/call_indirect.wast:610
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:612
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 0)]);
+
+// ./test/core/call_indirect.wast:613
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 11)]);
+
+// ./test/core/call_indirect.wast:614
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 9)]);
+
+// ./test/core/call_indirect.wast:615
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:616
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:617
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/call_indirect.wast:618
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i64", 1n)]);
+
+// ./test/core/call_indirect.wast:623
+let $1 = instantiate(`(module
+  (type $$ii-i (func (param i32 i32) (result i32)))
+
+  (table $$t1 funcref (elem $$f $$g))
+  (table $$t2 funcref (elem $$h $$i $$j))
+  (table $$t3 4 funcref)
+  (elem (table $$t3) (i32.const 0) func $$g $$h)
+  (elem (table $$t3) (i32.const 3) func $$z)
+
+  (func $$f (type $$ii-i) (i32.add (local.get 0) (local.get 1)))
+  (func $$g (type $$ii-i) (i32.sub (local.get 0) (local.get 1)))
+  (func $$h (type $$ii-i) (i32.mul (local.get 0) (local.get 1)))
+  (func $$i (type $$ii-i) (i32.div_u (local.get 0) (local.get 1)))
+  (func $$j (type $$ii-i) (i32.rem_u (local.get 0) (local.get 1)))
+  (func $$z)
+
+  (func (export "call-1") (param i32 i32 i32) (result i32)
+    (call_indirect $$t1 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-2") (param i32 i32 i32) (result i32)
+    (call_indirect $$t2 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-3") (param i32 i32 i32) (result i32)
+    (call_indirect $$t3 (type $$ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+)`);
+
+// ./test/core/call_indirect.wast:650
+assert_return(() => invoke($1, `call-1`, [2, 3, 0]), [value("i32", 5)]);
+
+// ./test/core/call_indirect.wast:651
+assert_return(() => invoke($1, `call-1`, [2, 3, 1]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:652
+assert_trap(() => invoke($1, `call-1`, [2, 3, 2]), `undefined element`);
+
+// ./test/core/call_indirect.wast:654
+assert_return(() => invoke($1, `call-2`, [2, 3, 0]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:655
+assert_return(() => invoke($1, `call-2`, [2, 3, 1]), [value("i32", 0)]);
+
+// ./test/core/call_indirect.wast:656
+assert_return(() => invoke($1, `call-2`, [2, 3, 2]), [value("i32", 2)]);
+
+// ./test/core/call_indirect.wast:657
+assert_trap(() => invoke($1, `call-2`, [2, 3, 3]), `undefined element`);
+
+// ./test/core/call_indirect.wast:659
+assert_return(() => invoke($1, `call-3`, [2, 3, 0]), [value("i32", -1)]);
+
+// ./test/core/call_indirect.wast:660
+assert_return(() => invoke($1, `call-3`, [2, 3, 1]), [value("i32", 6)]);
+
+// ./test/core/call_indirect.wast:661
+assert_trap(() => invoke($1, `call-3`, [2, 3, 2]), `uninitialized element`);
+
+// ./test/core/call_indirect.wast:662
+assert_trap(() => invoke($1, `call-3`, [2, 3, 3]), `indirect call type mismatch`);
+
+// ./test/core/call_indirect.wast:663
+assert_trap(() => invoke($1, `call-3`, [2, 3, 4]), `undefined element`);
+
+// ./test/core/call_indirect.wast:668
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (param i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:680
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (param i32) (type $$sig) (result i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:692
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (param i32) (result i32) (type $$sig)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:704
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (result i32) (type $$sig) (param i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:716
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (result i32) (param i32) (type $$sig)     (i32.const 0) (i32.const 0)   ) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:728
+assert_malformed(
+  () => instantiate(`(table 0 funcref) (func (result i32)   (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:738
+assert_malformed(
+  () => instantiate(`(table 0 funcref) (func (call_indirect (param $$x i32) (i32.const 0) (i32.const 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/call_indirect.wast:745
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:755
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (result i32) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:765
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (table 0 funcref) (func   (call_indirect (type $$sig) (param i32) (i32.const 0) (i32.const 0)) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:775
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (table 0 funcref) (func (result i32)   (call_indirect (type $$sig) (param i32) (result i32)     (i32.const 0) (i32.const 0)   ) ) `),
+  `inline function type`,
+);
+
+// ./test/core/call_indirect.wast:790
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (func $$no-table (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `unknown table`,
+);
+
+// ./test/core/call_indirect.wast:798
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:806
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $$type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:815
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:823
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $$arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:831
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:839
+assert_invalid(
+  () => instantiate(`(module
+    (type (func))
+    (table 0 funcref)
+    (func $$arity-2-vs-0
+      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:850
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:858
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $$type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:867
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $$type-first-void-vs-num
+      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:877
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $$type-second-void-vs-num
+      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:887
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $$type-first-num-vs-num
+      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:897
+assert_invalid(
+  () => instantiate(`(module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $$type-second-num-vs-num
+      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:908
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-block
+      (block
+        (call_indirect (type $$sig) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:921
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-block
+      (block
+        (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:934
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-loop
+      (loop
+        (call_indirect (type $$sig) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:947
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-loop
+      (loop
+        (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:960
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32))
+    (type $$sig (func (param i32)))
+    (table funcref (elem $$f))
+    (func $$type-first-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $$sig) (i32.const 0))
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:976
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32 i32))
+    (type $$sig (func (param i32 i32)))
+    (table funcref (elem $$f))
+    (func $$type-second-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $$sig) (i32.const 0) (i32.const 0))
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/call_indirect.wast:996
+assert_invalid(
+  () => instantiate(`(module
+    (table 0 funcref)
+    (func $$unbound-type (call_indirect (type 1) (i32.const 0)))
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1003
+assert_invalid(
+  () => instantiate(`(module
+    (table 0 funcref)
+    (func $$large-type (call_indirect (type 1012321300) (i32.const 0)))
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/call_indirect.wast:1014
+assert_invalid(
+  () => instantiate(`(module (table funcref (elem 0 0)))`),
+  `unknown function`,
+);
+
+// ./test/core/call_indirect.wast:1024
+let $2 = instantiate(`(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/js/src/jit-test/tests/wasm/spec/spec/comments.wast.js b/js/src/jit-test/tests/wasm/spec/spec/comments.wast.js
new file mode 100644
index 0000000000..8eee0e3cc2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/comments.wast.js
@@ -0,0 +1,34 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/comments.wast
+
+// ./test/core/comments.wast:10:0
+let $0 = instantiate(`(module;;comment
+)`);
+
+// ./test/core/comments.wast:56:11
+let $1 = instantiate(`(module(;comment;)
+(;comment;))`);
+
+// ./test/core/comments.wast:66
+let $2 = instantiate(`(module
+  (;comment(;nested(;further;)nested;)comment;)
+)`);
+
+// ./test/core/comments.wast:75
+let $3 = instantiate(`(module
+  (;comment;;comment(;nested;)comment;)
+)`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/const.wast.js b/js/src/jit-test/tests/wasm/spec/spec/const.wast.js
new file mode 100644
index 0000000000..c8c02698da
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/const.wast.js
@@ -0,0 +1,3114 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/const.wast
+
+// ./test/core/const.wast:5
+let $0 = instantiate(`(module (func (i32.const 0_123_456_789) drop))`);
+
+// ./test/core/const.wast:6
+let $1 = instantiate(`(module (func (i32.const 0x0_9acf_fBDF) drop))`);
+
+// ./test/core/const.wast:7
+assert_malformed(() => instantiate(`(func (i32.const) drop) `), `unexpected token`);
+
+// ./test/core/const.wast:11
+assert_malformed(() => instantiate(`(func (i32.const 0x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:15
+assert_malformed(() => instantiate(`(func (i32.const 1x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:19
+assert_malformed(() => instantiate(`(func (i32.const 0xg) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:24
+let $2 = instantiate(`(module (func (i64.const 0_123_456_789) drop))`);
+
+// ./test/core/const.wast:25
+let $3 = instantiate(`(module (func (i64.const 0x0125_6789_ADEF_bcef) drop))`);
+
+// ./test/core/const.wast:26
+assert_malformed(() => instantiate(`(func (i64.const) drop) `), `unexpected token`);
+
+// ./test/core/const.wast:30
+assert_malformed(() => instantiate(`(func (i64.const 0x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:34
+assert_malformed(() => instantiate(`(func (i64.const 1x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:38
+assert_malformed(() => instantiate(`(func (i64.const 0xg) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:43
+let $4 = instantiate(`(module (func (f32.const 0123456789) drop))`);
+
+// ./test/core/const.wast:44
+let $5 = instantiate(`(module (func (f32.const 0123456789e019) drop))`);
+
+// ./test/core/const.wast:45
+let $6 = instantiate(`(module (func (f32.const 0123456789e+019) drop))`);
+
+// ./test/core/const.wast:46
+let $7 = instantiate(`(module (func (f32.const 0123456789e-019) drop))`);
+
+// ./test/core/const.wast:47
+let $8 = instantiate(`(module (func (f32.const 0123456789.) drop))`);
+
+// ./test/core/const.wast:48
+let $9 = instantiate(`(module (func (f32.const 0123456789.e019) drop))`);
+
+// ./test/core/const.wast:49
+let $10 = instantiate(`(module (func (f32.const 0123456789.e+019) drop))`);
+
+// ./test/core/const.wast:50
+let $11 = instantiate(`(module (func (f32.const 0123456789.e-019) drop))`);
+
+// ./test/core/const.wast:51
+let $12 = instantiate(`(module (func (f32.const 0123456789.0123456789) drop))`);
+
+// ./test/core/const.wast:52
+let $13 = instantiate(`(module (func (f32.const 0123456789.0123456789e019) drop))`);
+
+// ./test/core/const.wast:53
+let $14 = instantiate(`(module (func (f32.const 0123456789.0123456789e+019) drop))`);
+
+// ./test/core/const.wast:54
+let $15 = instantiate(`(module (func (f32.const 0123456789.0123456789e-019) drop))`);
+
+// ./test/core/const.wast:55
+let $16 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF) drop))`);
+
+// ./test/core/const.wast:56
+let $17 = instantiate(`(module (func (f32.const 0x0123456789ABCDEFp019) drop))`);
+
+// ./test/core/const.wast:57
+let $18 = instantiate(`(module (func (f32.const 0x0123456789ABCDEFp+019) drop))`);
+
+// ./test/core/const.wast:58
+let $19 = instantiate(`(module (func (f32.const 0x0123456789ABCDEFp-019) drop))`);
+
+// ./test/core/const.wast:59
+let $20 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.) drop))`);
+
+// ./test/core/const.wast:60
+let $21 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.p019) drop))`);
+
+// ./test/core/const.wast:61
+let $22 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.p+019) drop))`);
+
+// ./test/core/const.wast:62
+let $23 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.p-019) drop))`);
+
+// ./test/core/const.wast:63
+let $24 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aF) drop))`);
+
+// ./test/core/const.wast:64
+let $25 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aFp019) drop))`);
+
+// ./test/core/const.wast:65
+let $26 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aFp+019) drop))`);
+
+// ./test/core/const.wast:66
+let $27 = instantiate(`(module (func (f32.const 0x0123456789ABCDEF.019aFp-019) drop))`);
+
+// ./test/core/const.wast:67
+assert_malformed(() => instantiate(`(func (f32.const) drop) `), `unexpected token`);
+
+// ./test/core/const.wast:71
+assert_malformed(() => instantiate(`(func (f32.const .0) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:75
+assert_malformed(() => instantiate(`(func (f32.const .0e0) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:79
+assert_malformed(() => instantiate(`(func (f32.const 0e) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:83
+assert_malformed(() => instantiate(`(func (f32.const 0e+) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:87
+assert_malformed(() => instantiate(`(func (f32.const 0.0e) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:91
+assert_malformed(() => instantiate(`(func (f32.const 0.0e-) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:95
+assert_malformed(() => instantiate(`(func (f32.const 0x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:99
+assert_malformed(() => instantiate(`(func (f32.const 1x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:103
+assert_malformed(() => instantiate(`(func (f32.const 0xg) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:107
+assert_malformed(() => instantiate(`(func (f32.const 0x.) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:111
+assert_malformed(() => instantiate(`(func (f32.const 0x0.g) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:115
+assert_malformed(() => instantiate(`(func (f32.const 0x0p) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:119
+assert_malformed(() => instantiate(`(func (f32.const 0x0p+) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:123
+assert_malformed(() => instantiate(`(func (f32.const 0x0p-) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:127
+assert_malformed(() => instantiate(`(func (f32.const 0x0.0p) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:131
+assert_malformed(
+  () => instantiate(`(func (f32.const 0x0.0p+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/const.wast:135
+assert_malformed(
+  () => instantiate(`(func (f32.const 0x0.0p-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/const.wast:139
+assert_malformed(() => instantiate(`(func (f32.const 0x0pA) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:145
+let $28 = instantiate(`(module (func (f64.const 0123456789) drop))`);
+
+// ./test/core/const.wast:146
+let $29 = instantiate(`(module (func (f64.const 0123456789e019) drop))`);
+
+// ./test/core/const.wast:147
+let $30 = instantiate(`(module (func (f64.const 0123456789e+019) drop))`);
+
+// ./test/core/const.wast:148
+let $31 = instantiate(`(module (func (f64.const 0123456789e-019) drop))`);
+
+// ./test/core/const.wast:149
+let $32 = instantiate(`(module (func (f64.const 0123456789.) drop))`);
+
+// ./test/core/const.wast:150
+let $33 = instantiate(`(module (func (f64.const 0123456789.e019) drop))`);
+
+// ./test/core/const.wast:151
+let $34 = instantiate(`(module (func (f64.const 0123456789.e+019) drop))`);
+
+// ./test/core/const.wast:152
+let $35 = instantiate(`(module (func (f64.const 0123456789.e-019) drop))`);
+
+// ./test/core/const.wast:153
+let $36 = instantiate(`(module (func (f64.const 0123456789.0123456789) drop))`);
+
+// ./test/core/const.wast:154
+let $37 = instantiate(`(module (func (f64.const 0123456789.0123456789e019) drop))`);
+
+// ./test/core/const.wast:155
+let $38 = instantiate(`(module (func (f64.const 0123456789.0123456789e+019) drop))`);
+
+// ./test/core/const.wast:156
+let $39 = instantiate(`(module (func (f64.const 0123456789.0123456789e-019) drop))`);
+
+// ./test/core/const.wast:157
+let $40 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9) drop))`);
+
+// ./test/core/const.wast:158
+let $41 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.) drop))`);
+
+// ./test/core/const.wast:159
+let $42 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9) drop))`);
+
+// ./test/core/const.wast:160
+let $43 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9e+0_1_9) drop))`);
+
+// ./test/core/const.wast:161
+let $44 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.e+0_1_9) drop))`);
+
+// ./test/core/const.wast:162
+let $45 = instantiate(`(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9e0_1_9) drop))`);
+
+// ./test/core/const.wast:164
+let $46 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef) drop))`);
+
+// ./test/core/const.wast:165
+let $47 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdefp019) drop))`);
+
+// ./test/core/const.wast:166
+let $48 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdefp+019) drop))`);
+
+// ./test/core/const.wast:167
+let $49 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdefp-019) drop))`);
+
+// ./test/core/const.wast:168
+let $50 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.) drop))`);
+
+// ./test/core/const.wast:169
+let $51 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.p019) drop))`);
+
+// ./test/core/const.wast:170
+let $52 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.p+019) drop))`);
+
+// ./test/core/const.wast:171
+let $53 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.p-019) drop))`);
+
+// ./test/core/const.wast:172
+let $54 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))`);
+
+// ./test/core/const.wast:173
+let $55 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))`);
+
+// ./test/core/const.wast:174
+let $56 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))`);
+
+// ./test/core/const.wast:175
+let $57 = instantiate(`(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))`);
+
+// ./test/core/const.wast:176
+let $58 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop))`);
+
+// ./test/core/const.wast:177
+let $59 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.) drop))`);
+
+// ./test/core/const.wast:178
+let $60 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop))`);
+
+// ./test/core/const.wast:179
+let $61 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop))`);
+
+// ./test/core/const.wast:180
+let $62 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.p0_1_9) drop))`);
+
+// ./test/core/const.wast:181
+let $63 = instantiate(`(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop))`);
+
+// ./test/core/const.wast:184
+assert_malformed(() => instantiate(`(func (f64.const) drop) `), `unexpected token`);
+
+// ./test/core/const.wast:188
+assert_malformed(() => instantiate(`(func (f64.const .0) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:192
+assert_malformed(() => instantiate(`(func (f64.const .0e0) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:196
+assert_malformed(() => instantiate(`(func (f64.const 0e) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:200
+assert_malformed(() => instantiate(`(func (f64.const 0e+) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:204
+assert_malformed(() => instantiate(`(func (f64.const 0.0e) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:208
+assert_malformed(() => instantiate(`(func (f64.const 0.0e-) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:212
+assert_malformed(() => instantiate(`(func (f64.const 0x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:216
+assert_malformed(() => instantiate(`(func (f64.const 1x) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:220
+assert_malformed(() => instantiate(`(func (f64.const 0xg) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:224
+assert_malformed(() => instantiate(`(func (f64.const 0x.) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:228
+assert_malformed(() => instantiate(`(func (f64.const 0x0.g) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:232
+assert_malformed(() => instantiate(`(func (f64.const 0x0p) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:236
+assert_malformed(() => instantiate(`(func (f64.const 0x0p+) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:240
+assert_malformed(() => instantiate(`(func (f64.const 0x0p-) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:244
+assert_malformed(() => instantiate(`(func (f64.const 0x0.0p) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:248
+assert_malformed(
+  () => instantiate(`(func (f64.const 0x0.0p+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/const.wast:252
+assert_malformed(
+  () => instantiate(`(func (f64.const 0x0.0p-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/const.wast:256
+assert_malformed(() => instantiate(`(func (f64.const 0x0pA) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:264
+let $64 = instantiate(`(module (func (i32.const 0xffffffff) drop))`);
+
+// ./test/core/const.wast:265
+let $65 = instantiate(`(module (func (i32.const -0x80000000) drop))`);
+
+// ./test/core/const.wast:266
+assert_malformed(
+  () => instantiate(`(func (i32.const 0x100000000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:270
+assert_malformed(
+  () => instantiate(`(func (i32.const -0x80000001) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:275
+let $66 = instantiate(`(module (func (i32.const 4294967295) drop))`);
+
+// ./test/core/const.wast:276
+let $67 = instantiate(`(module (func (i32.const -2147483648) drop))`);
+
+// ./test/core/const.wast:277
+assert_malformed(
+  () => instantiate(`(func (i32.const 4294967296) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:281
+assert_malformed(
+  () => instantiate(`(func (i32.const -2147483649) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:286
+let $68 = instantiate(`(module (func (i64.const 0xffffffffffffffff) drop))`);
+
+// ./test/core/const.wast:287
+let $69 = instantiate(`(module (func (i64.const -0x8000000000000000) drop))`);
+
+// ./test/core/const.wast:288
+assert_malformed(
+  () => instantiate(`(func (i64.const 0x10000000000000000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:292
+assert_malformed(
+  () => instantiate(`(func (i64.const -0x8000000000000001) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:297
+let $70 = instantiate(`(module (func (i64.const 18446744073709551615) drop))`);
+
+// ./test/core/const.wast:298
+let $71 = instantiate(`(module (func (i64.const -9223372036854775808) drop))`);
+
+// ./test/core/const.wast:299
+assert_malformed(
+  () => instantiate(`(func (i64.const 18446744073709551616) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:303
+assert_malformed(
+  () => instantiate(`(func (i64.const -9223372036854775809) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:308
+let $72 = instantiate(`(module (func (f32.const 0x1p127) drop))`);
+
+// ./test/core/const.wast:309
+let $73 = instantiate(`(module (func (f32.const -0x1p127) drop))`);
+
+// ./test/core/const.wast:310
+let $74 = instantiate(`(module (func (f32.const 0x1.fffffep127) drop))`);
+
+// ./test/core/const.wast:311
+let $75 = instantiate(`(module (func (f32.const -0x1.fffffep127) drop))`);
+
+// ./test/core/const.wast:312
+let $76 = instantiate(`(module (func (f32.const 0x1.fffffe7p127) drop))`);
+
+// ./test/core/const.wast:313
+let $77 = instantiate(`(module (func (f32.const -0x1.fffffe7p127) drop))`);
+
+// ./test/core/const.wast:314
+let $78 = instantiate(`(module (func (f32.const 0x1.fffffefffffff8000000p127) drop))`);
+
+// ./test/core/const.wast:315
+let $79 = instantiate(`(module (func (f32.const -0x1.fffffefffffff8000000p127) drop))`);
+
+// ./test/core/const.wast:316
+let $80 = instantiate(`(module (func (f32.const 0x1.fffffefffffffffffffp127) drop))`);
+
+// ./test/core/const.wast:317
+let $81 = instantiate(`(module (func (f32.const -0x1.fffffefffffffffffffp127) drop))`);
+
+// ./test/core/const.wast:318
+assert_malformed(
+  () => instantiate(`(func (f32.const 0x1p128) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:322
+assert_malformed(
+  () => instantiate(`(func (f32.const -0x1p128) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:326
+assert_malformed(
+  () => instantiate(`(func (f32.const 0x1.ffffffp127) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:330
+assert_malformed(
+  () => instantiate(`(func (f32.const -0x1.ffffffp127) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:335
+let $82 = instantiate(`(module (func (f32.const 1e38) drop))`);
+
+// ./test/core/const.wast:336
+let $83 = instantiate(`(module (func (f32.const -1e38) drop))`);
+
+// ./test/core/const.wast:337
+assert_malformed(
+  () => instantiate(`(func (f32.const 1e39) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:341
+assert_malformed(
+  () => instantiate(`(func (f32.const -1e39) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:346
+let $84 = instantiate(`(module (func (f32.const 340282356779733623858607532500980858880) drop))`);
+
+// ./test/core/const.wast:347
+let $85 = instantiate(`(module (func (f32.const -340282356779733623858607532500980858880) drop))`);
+
+// ./test/core/const.wast:348
+assert_malformed(
+  () => instantiate(`(func (f32.const 340282356779733661637539395458142568448) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:352
+assert_malformed(
+  () => instantiate(`(func (f32.const -340282356779733661637539395458142568448) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:357
+let $86 = instantiate(`(module (func (f64.const 0x1p1023) drop))`);
+
+// ./test/core/const.wast:358
+let $87 = instantiate(`(module (func (f64.const -0x1p1023) drop))`);
+
+// ./test/core/const.wast:359
+let $88 = instantiate(`(module (func (f64.const 0x1.fffffffffffffp1023) drop))`);
+
+// ./test/core/const.wast:360
+let $89 = instantiate(`(module (func (f64.const -0x1.fffffffffffffp1023) drop))`);
+
+// ./test/core/const.wast:361
+let $90 = instantiate(`(module (func (f64.const 0x1.fffffffffffff7p1023) drop))`);
+
+// ./test/core/const.wast:362
+let $91 = instantiate(`(module (func (f64.const -0x1.fffffffffffff7p1023) drop))`);
+
+// ./test/core/const.wast:363
+let $92 = instantiate(`(module (func (f64.const 0x1.fffffffffffff7ffffffp1023) drop))`);
+
+// ./test/core/const.wast:364
+let $93 = instantiate(`(module (func (f64.const -0x1.fffffffffffff7ffffffp1023) drop))`);
+
+// ./test/core/const.wast:365
+assert_malformed(
+  () => instantiate(`(func (f64.const 0x1p1024) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:369
+assert_malformed(
+  () => instantiate(`(func (f64.const -0x1p1024) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:373
+assert_malformed(
+  () => instantiate(`(func (f64.const 0x1.fffffffffffff8p1023) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:377
+assert_malformed(
+  () => instantiate(`(func (f64.const -0x1.fffffffffffff8p1023) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:382
+let $94 = instantiate(`(module (func (f64.const 1e308) drop))`);
+
+// ./test/core/const.wast:383
+let $95 = instantiate(`(module (func (f64.const -1e308) drop))`);
+
+// ./test/core/const.wast:384
+assert_malformed(
+  () => instantiate(`(func (f64.const 1e309) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:388
+assert_malformed(
+  () => instantiate(`(func (f64.const -1e309) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:393
+let $96 = instantiate(`(module (func (f64.const 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))`);
+
+// ./test/core/const.wast:394
+let $97 = instantiate(`(module (func (f64.const -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))`);
+
+// ./test/core/const.wast:395
+assert_malformed(
+  () => instantiate(`(func (f64.const 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:399
+assert_malformed(
+  () => instantiate(`(func (f64.const -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:404
+let $98 = instantiate(`(module (func (f32.const nan:0x1) drop))`);
+
+// ./test/core/const.wast:405
+let $99 = instantiate(`(module (func (f64.const nan:0x1) drop))`);
+
+// ./test/core/const.wast:406
+let $100 = instantiate(`(module (func (f32.const nan:0x7f_ffff) drop))`);
+
+// ./test/core/const.wast:407
+let $101 = instantiate(`(module (func (f64.const nan:0xf_ffff_ffff_ffff) drop))`);
+
+// ./test/core/const.wast:409
+assert_malformed(() => instantiate(`(func (f32.const nan:1) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:413
+assert_malformed(() => instantiate(`(func (f64.const nan:1) drop) `), `unknown operator`);
+
+// ./test/core/const.wast:418
+assert_malformed(
+  () => instantiate(`(func (f32.const nan:0x0) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:422
+assert_malformed(
+  () => instantiate(`(func (f64.const nan:0x0) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:427
+assert_malformed(
+  () => instantiate(`(func (f32.const nan:0x80_0000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:431
+assert_malformed(
+  () => instantiate(`(func (f64.const nan:0x10_0000_0000_0000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/const.wast:440
+let $102 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p-50)))`);
+
+// ./test/core/const.wast:441
+assert_return(() => invoke($102, `f`, []), [value("f32", 0.0000000000000008881784)]);
+
+// ./test/core/const.wast:442
+let $103 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p-50)))`);
+
+// ./test/core/const.wast:443
+assert_return(() => invoke($103, `f`, []), [value("f32", -0.0000000000000008881784)]);
+
+// ./test/core/const.wast:444
+let $104 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p-50)))`);
+
+// ./test/core/const.wast:445
+assert_return(() => invoke($104, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:446
+let $105 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p-50)))`);
+
+// ./test/core/const.wast:447
+assert_return(() => invoke($105, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:448
+let $106 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp-50)))`);
+
+// ./test/core/const.wast:449
+assert_return(() => invoke($106, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:450
+let $107 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp-50)))`);
+
+// ./test/core/const.wast:451
+assert_return(() => invoke($107, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:452
+let $108 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p-50)))`);
+
+// ./test/core/const.wast:453
+assert_return(() => invoke($108, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:454
+let $109 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p-50)))`);
+
+// ./test/core/const.wast:455
+assert_return(() => invoke($109, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:456
+let $110 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p-50)))`);
+
+// ./test/core/const.wast:457
+assert_return(() => invoke($110, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:458
+let $111 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p-50)))`);
+
+// ./test/core/const.wast:459
+assert_return(() => invoke($111, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:460
+let $112 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp-50)))`);
+
+// ./test/core/const.wast:461
+assert_return(() => invoke($112, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:462
+let $113 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp-50)))`);
+
+// ./test/core/const.wast:463
+assert_return(() => invoke($113, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:464
+let $114 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p-50)))`);
+
+// ./test/core/const.wast:465
+assert_return(() => invoke($114, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:466
+let $115 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p-50)))`);
+
+// ./test/core/const.wast:467
+assert_return(() => invoke($115, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:468
+let $116 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p-50)))`);
+
+// ./test/core/const.wast:469
+assert_return(() => invoke($116, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:470
+let $117 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p-50)))`);
+
+// ./test/core/const.wast:471
+assert_return(() => invoke($117, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:472
+let $118 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp-50)))`);
+
+// ./test/core/const.wast:473
+assert_return(() => invoke($118, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:474
+let $119 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp-50)))`);
+
+// ./test/core/const.wast:475
+assert_return(() => invoke($119, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:476
+let $120 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p-50)))`);
+
+// ./test/core/const.wast:477
+assert_return(() => invoke($120, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:478
+let $121 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p-50)))`);
+
+// ./test/core/const.wast:479
+assert_return(() => invoke($121, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:480
+let $122 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p-50)))`);
+
+// ./test/core/const.wast:481
+assert_return(() => invoke($122, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:482
+let $123 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p-50)))`);
+
+// ./test/core/const.wast:483
+assert_return(() => invoke($123, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:484
+let $124 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp-50)))`);
+
+// ./test/core/const.wast:485
+assert_return(() => invoke($124, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:486
+let $125 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp-50)))`);
+
+// ./test/core/const.wast:487
+assert_return(() => invoke($125, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:488
+let $126 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p-50)))`);
+
+// ./test/core/const.wast:489
+assert_return(() => invoke($126, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:490
+let $127 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p-50)))`);
+
+// ./test/core/const.wast:491
+assert_return(() => invoke($127, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:492
+let $128 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p-50)))`);
+
+// ./test/core/const.wast:493
+assert_return(() => invoke($128, `f`, []), [value("f32", 0.0000000000000008881787)]);
+
+// ./test/core/const.wast:494
+let $129 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p-50)))`);
+
+// ./test/core/const.wast:495
+assert_return(() => invoke($129, `f`, []), [value("f32", -0.0000000000000008881787)]);
+
+// ./test/core/const.wast:497
+let $130 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.004000000p-64)))`);
+
+// ./test/core/const.wast:498
+assert_return(() => invoke($130, `f`, []), [value("f32", 0.0000000000000008881784)]);
+
+// ./test/core/const.wast:499
+let $131 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.004000000p-64)))`);
+
+// ./test/core/const.wast:500
+assert_return(() => invoke($131, `f`, []), [value("f32", -0.0000000000000008881784)]);
+
+// ./test/core/const.wast:501
+let $132 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.004000001p-64)))`);
+
+// ./test/core/const.wast:502
+assert_return(() => invoke($132, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:503
+let $133 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.004000001p-64)))`);
+
+// ./test/core/const.wast:504
+assert_return(() => invoke($133, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:505
+let $134 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.007ffffffp-64)))`);
+
+// ./test/core/const.wast:506
+assert_return(() => invoke($134, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:507
+let $135 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.007ffffffp-64)))`);
+
+// ./test/core/const.wast:508
+assert_return(() => invoke($135, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:509
+let $136 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.008000000p-64)))`);
+
+// ./test/core/const.wast:510
+assert_return(() => invoke($136, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:511
+let $137 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.008000000p-64)))`);
+
+// ./test/core/const.wast:512
+assert_return(() => invoke($137, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:513
+let $138 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.008000001p-64)))`);
+
+// ./test/core/const.wast:514
+assert_return(() => invoke($138, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:515
+let $139 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.008000001p-64)))`);
+
+// ./test/core/const.wast:516
+assert_return(() => invoke($139, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:517
+let $140 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00bffffffp-64)))`);
+
+// ./test/core/const.wast:518
+assert_return(() => invoke($140, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:519
+let $141 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00bffffffp-64)))`);
+
+// ./test/core/const.wast:520
+assert_return(() => invoke($141, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:521
+let $142 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00c000000p-64)))`);
+
+// ./test/core/const.wast:522
+assert_return(() => invoke($142, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:523
+let $143 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00c000000p-64)))`);
+
+// ./test/core/const.wast:524
+assert_return(() => invoke($143, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:525
+let $144 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00c000001p-64)))`);
+
+// ./test/core/const.wast:526
+assert_return(() => invoke($144, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:527
+let $145 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00c000001p-64)))`);
+
+// ./test/core/const.wast:528
+assert_return(() => invoke($145, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:529
+let $146 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.00fffffffp-64)))`);
+
+// ./test/core/const.wast:530
+assert_return(() => invoke($146, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:531
+let $147 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.00fffffffp-64)))`);
+
+// ./test/core/const.wast:532
+assert_return(() => invoke($147, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:533
+let $148 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.010000001p-64)))`);
+
+// ./test/core/const.wast:534
+assert_return(() => invoke($148, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:535
+let $149 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.010000001p-64)))`);
+
+// ./test/core/const.wast:536
+assert_return(() => invoke($149, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:537
+let $150 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.013ffffffp-64)))`);
+
+// ./test/core/const.wast:538
+assert_return(() => invoke($150, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:539
+let $151 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.013ffffffp-64)))`);
+
+// ./test/core/const.wast:540
+assert_return(() => invoke($151, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:541
+let $152 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000.014000001p-64)))`);
+
+// ./test/core/const.wast:542
+assert_return(() => invoke($152, `f`, []), [value("f32", 0.0000000000000008881787)]);
+
+// ./test/core/const.wast:543
+let $153 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000.014000001p-64)))`);
+
+// ./test/core/const.wast:544
+assert_return(() => invoke($153, `f`, []), [value("f32", -0.0000000000000008881787)]);
+
+// ./test/core/const.wast:546
+let $154 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817847263968443573e-16)))`);
+
+// ./test/core/const.wast:547
+assert_return(() => invoke($154, `f`, []), [value("f32", 0.0000000000000008881784)]);
+
+// ./test/core/const.wast:548
+let $155 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817847263968443573e-16)))`);
+
+// ./test/core/const.wast:549
+assert_return(() => invoke($155, `f`, []), [value("f32", -0.0000000000000008881784)]);
+
+// ./test/core/const.wast:550
+let $156 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817847263968443574e-16)))`);
+
+// ./test/core/const.wast:551
+assert_return(() => invoke($156, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:552
+let $157 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817847263968443574e-16)))`);
+
+// ./test/core/const.wast:553
+assert_return(() => invoke($157, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:554
+let $158 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817857851880284252e-16)))`);
+
+// ./test/core/const.wast:555
+assert_return(() => invoke($158, `f`, []), [value("f32", 0.0000000000000008881785)]);
+
+// ./test/core/const.wast:556
+let $159 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817857851880284252e-16)))`);
+
+// ./test/core/const.wast:557
+assert_return(() => invoke($159, `f`, []), [value("f32", -0.0000000000000008881785)]);
+
+// ./test/core/const.wast:558
+let $160 = instantiate(`(module (func (export "f") (result f32) (f32.const +8.8817857851880284253e-16)))`);
+
+// ./test/core/const.wast:559
+assert_return(() => invoke($160, `f`, []), [value("f32", 0.0000000000000008881786)]);
+
+// ./test/core/const.wast:560
+let $161 = instantiate(`(module (func (export "f") (result f32) (f32.const -8.8817857851880284253e-16)))`);
+
+// ./test/core/const.wast:561
+assert_return(() => invoke($161, `f`, []), [value("f32", -0.0000000000000008881786)]);
+
+// ./test/core/const.wast:564
+let $162 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p+50)))`);
+
+// ./test/core/const.wast:565
+assert_return(() => invoke($162, `f`, []), [value("f32", 1125899900000000)]);
+
+// ./test/core/const.wast:566
+let $163 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p+50)))`);
+
+// ./test/core/const.wast:567
+assert_return(() => invoke($163, `f`, []), [value("f32", -1125899900000000)]);
+
+// ./test/core/const.wast:568
+let $164 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p+50)))`);
+
+// ./test/core/const.wast:569
+assert_return(() => invoke($164, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:570
+let $165 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p+50)))`);
+
+// ./test/core/const.wast:571
+assert_return(() => invoke($165, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:572
+let $166 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp+50)))`);
+
+// ./test/core/const.wast:573
+assert_return(() => invoke($166, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:574
+let $167 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp+50)))`);
+
+// ./test/core/const.wast:575
+assert_return(() => invoke($167, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:576
+let $168 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p+50)))`);
+
+// ./test/core/const.wast:577
+assert_return(() => invoke($168, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:578
+let $169 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p+50)))`);
+
+// ./test/core/const.wast:579
+assert_return(() => invoke($169, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:580
+let $170 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p+50)))`);
+
+// ./test/core/const.wast:581
+assert_return(() => invoke($170, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:582
+let $171 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p+50)))`);
+
+// ./test/core/const.wast:583
+assert_return(() => invoke($171, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:584
+let $172 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp+50)))`);
+
+// ./test/core/const.wast:585
+assert_return(() => invoke($172, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:586
+let $173 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp+50)))`);
+
+// ./test/core/const.wast:587
+assert_return(() => invoke($173, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:588
+let $174 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p+50)))`);
+
+// ./test/core/const.wast:589
+assert_return(() => invoke($174, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:590
+let $175 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p+50)))`);
+
+// ./test/core/const.wast:591
+assert_return(() => invoke($175, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:592
+let $176 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p+50)))`);
+
+// ./test/core/const.wast:593
+assert_return(() => invoke($176, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:594
+let $177 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p+50)))`);
+
+// ./test/core/const.wast:595
+assert_return(() => invoke($177, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:596
+let $178 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp+50)))`);
+
+// ./test/core/const.wast:597
+assert_return(() => invoke($178, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:598
+let $179 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp+50)))`);
+
+// ./test/core/const.wast:599
+assert_return(() => invoke($179, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:600
+let $180 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p+50)))`);
+
+// ./test/core/const.wast:601
+assert_return(() => invoke($180, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:602
+let $181 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p+50)))`);
+
+// ./test/core/const.wast:603
+assert_return(() => invoke($181, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:604
+let $182 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p+50)))`);
+
+// ./test/core/const.wast:605
+assert_return(() => invoke($182, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:606
+let $183 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p+50)))`);
+
+// ./test/core/const.wast:607
+assert_return(() => invoke($183, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:608
+let $184 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp+50)))`);
+
+// ./test/core/const.wast:609
+assert_return(() => invoke($184, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:610
+let $185 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp+50)))`);
+
+// ./test/core/const.wast:611
+assert_return(() => invoke($185, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:612
+let $186 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p+50)))`);
+
+// ./test/core/const.wast:613
+assert_return(() => invoke($186, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:614
+let $187 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p+50)))`);
+
+// ./test/core/const.wast:615
+assert_return(() => invoke($187, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:616
+let $188 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p+50)))`);
+
+// ./test/core/const.wast:617
+assert_return(() => invoke($188, `f`, []), [value("f32", 1125900300000000)]);
+
+// ./test/core/const.wast:618
+let $189 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p+50)))`);
+
+// ./test/core/const.wast:619
+assert_return(() => invoke($189, `f`, []), [value("f32", -1125900300000000)]);
+
+// ./test/core/const.wast:621
+let $190 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000004000000)))`);
+
+// ./test/core/const.wast:622
+assert_return(() => invoke($190, `f`, []), [value("f32", 1125899900000000)]);
+
+// ./test/core/const.wast:623
+let $191 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000004000000)))`);
+
+// ./test/core/const.wast:624
+assert_return(() => invoke($191, `f`, []), [value("f32", -1125899900000000)]);
+
+// ./test/core/const.wast:625
+let $192 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000004000001)))`);
+
+// ./test/core/const.wast:626
+assert_return(() => invoke($192, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:627
+let $193 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000004000001)))`);
+
+// ./test/core/const.wast:628
+assert_return(() => invoke($193, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:629
+let $194 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000007ffffff)))`);
+
+// ./test/core/const.wast:630
+assert_return(() => invoke($194, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:631
+let $195 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000007ffffff)))`);
+
+// ./test/core/const.wast:632
+assert_return(() => invoke($195, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:633
+let $196 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000008000000)))`);
+
+// ./test/core/const.wast:634
+assert_return(() => invoke($196, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:635
+let $197 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000008000000)))`);
+
+// ./test/core/const.wast:636
+assert_return(() => invoke($197, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:637
+let $198 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x4000008000001)))`);
+
+// ./test/core/const.wast:638
+assert_return(() => invoke($198, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:639
+let $199 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x4000008000001)))`);
+
+// ./test/core/const.wast:640
+assert_return(() => invoke($199, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:641
+let $200 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x400000bffffff)))`);
+
+// ./test/core/const.wast:642
+assert_return(() => invoke($200, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:643
+let $201 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x400000bffffff)))`);
+
+// ./test/core/const.wast:644
+assert_return(() => invoke($201, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:645
+let $202 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x400000c000000)))`);
+
+// ./test/core/const.wast:646
+assert_return(() => invoke($202, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:647
+let $203 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x400000c000000)))`);
+
+// ./test/core/const.wast:648
+assert_return(() => invoke($203, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:650
+let $204 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125899973951488)))`);
+
+// ./test/core/const.wast:651
+assert_return(() => invoke($204, `f`, []), [value("f32", 1125899900000000)]);
+
+// ./test/core/const.wast:652
+let $205 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125899973951488)))`);
+
+// ./test/core/const.wast:653
+assert_return(() => invoke($205, `f`, []), [value("f32", -1125899900000000)]);
+
+// ./test/core/const.wast:654
+let $206 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125899973951489)))`);
+
+// ./test/core/const.wast:655
+assert_return(() => invoke($206, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:656
+let $207 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125899973951489)))`);
+
+// ./test/core/const.wast:657
+assert_return(() => invoke($207, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:658
+let $208 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125900108169215)))`);
+
+// ./test/core/const.wast:659
+assert_return(() => invoke($208, `f`, []), [value("f32", 1125900000000000)]);
+
+// ./test/core/const.wast:660
+let $209 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125900108169215)))`);
+
+// ./test/core/const.wast:661
+assert_return(() => invoke($209, `f`, []), [value("f32", -1125900000000000)]);
+
+// ./test/core/const.wast:662
+let $210 = instantiate(`(module (func (export "f") (result f32) (f32.const +1125900108169216)))`);
+
+// ./test/core/const.wast:663
+assert_return(() => invoke($210, `f`, []), [value("f32", 1125900200000000)]);
+
+// ./test/core/const.wast:664
+let $211 = instantiate(`(module (func (export "f") (result f32) (f32.const -1125900108169216)))`);
+
+// ./test/core/const.wast:665
+assert_return(() => invoke($211, `f`, []), [value("f32", -1125900200000000)]);
+
+// ./test/core/const.wast:668
+let $212 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000100000000000p-126)))`);
+
+// ./test/core/const.wast:669
+assert_return(() => invoke($212, `f`, []), [value("f32", 0)]);
+
+// ./test/core/const.wast:670
+let $213 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000100000000000p-126)))`);
+
+// ./test/core/const.wast:671
+assert_return(() => invoke($213, `f`, []), [value("f32", -0)]);
+
+// ./test/core/const.wast:672
+let $214 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000100000000001p-126)))`);
+
+// ./test/core/const.wast:673
+assert_return(
+  () => invoke($214, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:674
+let $215 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000100000000001p-126)))`);
+
+// ./test/core/const.wast:675
+assert_return(
+  () => invoke($215, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:676
+let $216 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000001fffffffffffp-126)))`);
+
+// ./test/core/const.wast:677
+assert_return(
+  () => invoke($216, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:678
+let $217 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000001fffffffffffp-126)))`);
+
+// ./test/core/const.wast:679
+assert_return(
+  () => invoke($217, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:680
+let $218 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000200000000000p-126)))`);
+
+// ./test/core/const.wast:681
+assert_return(
+  () => invoke($218, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:682
+let $219 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000200000000000p-126)))`);
+
+// ./test/core/const.wast:683
+assert_return(
+  () => invoke($219, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:684
+let $220 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000200000000001p-126)))`);
+
+// ./test/core/const.wast:685
+assert_return(
+  () => invoke($220, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:686
+let $221 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000200000000001p-126)))`);
+
+// ./test/core/const.wast:687
+assert_return(
+  () => invoke($221, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:688
+let $222 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000002fffffffffffp-126)))`);
+
+// ./test/core/const.wast:689
+assert_return(
+  () => invoke($222, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:690
+let $223 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000002fffffffffffp-126)))`);
+
+// ./test/core/const.wast:691
+assert_return(
+  () => invoke($223, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/const.wast:692
+let $224 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000300000000000p-126)))`);
+
+// ./test/core/const.wast:693
+assert_return(
+  () => invoke($224, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:694
+let $225 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000300000000000p-126)))`);
+
+// ./test/core/const.wast:695
+assert_return(
+  () => invoke($225, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:696
+let $226 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000300000000001p-126)))`);
+
+// ./test/core/const.wast:697
+assert_return(
+  () => invoke($226, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:698
+let $227 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000300000000001p-126)))`);
+
+// ./test/core/const.wast:699
+assert_return(
+  () => invoke($227, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:700
+let $228 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000003fffffffffffp-126)))`);
+
+// ./test/core/const.wast:701
+assert_return(
+  () => invoke($228, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:702
+let $229 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000003fffffffffffp-126)))`);
+
+// ./test/core/const.wast:703
+assert_return(
+  () => invoke($229, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:704
+let $230 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000400000000000p-126)))`);
+
+// ./test/core/const.wast:705
+assert_return(
+  () => invoke($230, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:706
+let $231 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000400000000000p-126)))`);
+
+// ./test/core/const.wast:707
+assert_return(
+  () => invoke($231, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:708
+let $232 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000400000000001p-126)))`);
+
+// ./test/core/const.wast:709
+assert_return(
+  () => invoke($232, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:710
+let $233 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000400000000001p-126)))`);
+
+// ./test/core/const.wast:711
+assert_return(
+  () => invoke($233, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:712
+let $234 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.000004fffffffffffp-126)))`);
+
+// ./test/core/const.wast:713
+assert_return(
+  () => invoke($234, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:714
+let $235 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.000004fffffffffffp-126)))`);
+
+// ./test/core/const.wast:715
+assert_return(
+  () => invoke($235, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:716
+let $236 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000500000000000p-126)))`);
+
+// ./test/core/const.wast:717
+assert_return(
+  () => invoke($236, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:718
+let $237 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000500000000000p-126)))`);
+
+// ./test/core/const.wast:719
+assert_return(
+  () => invoke($237, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/const.wast:720
+let $238 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x0.00000500000000001p-126)))`);
+
+// ./test/core/const.wast:721
+assert_return(
+  () => invoke($238, `f`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000004)],
+);
+
+// ./test/core/const.wast:722
+let $239 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x0.00000500000000001p-126)))`);
+
+// ./test/core/const.wast:723
+assert_return(
+  () => invoke($239, `f`, []),
+  [value("f32", -0.000000000000000000000000000000000000000000004)],
+);
+
+// ./test/core/const.wast:726
+let $240 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.fffffe8p127)))`);
+
+// ./test/core/const.wast:727
+assert_return(() => invoke($240, `f`, []), [value("f32", 340282350000000000000000000000000000000)]);
+
+// ./test/core/const.wast:728
+let $241 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.fffffe8p127)))`);
+
+// ./test/core/const.wast:729
+assert_return(() => invoke($241, `f`, []), [value("f32", -340282350000000000000000000000000000000)]);
+
+// ./test/core/const.wast:730
+let $242 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffff8p127)))`);
+
+// ./test/core/const.wast:731
+assert_return(() => invoke($242, `f`, []), [value("f32", 340282350000000000000000000000000000000)]);
+
+// ./test/core/const.wast:732
+let $243 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffff8p127)))`);
+
+// ./test/core/const.wast:733
+assert_return(() => invoke($243, `f`, []), [value("f32", -340282350000000000000000000000000000000)]);
+
+// ./test/core/const.wast:734
+let $244 = instantiate(`(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffffffffp127)))`);
+
+// ./test/core/const.wast:735
+assert_return(() => invoke($244, `f`, []), [value("f32", 340282350000000000000000000000000000000)]);
+
+// ./test/core/const.wast:736
+let $245 = instantiate(`(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffffffffp127)))`);
+
+// ./test/core/const.wast:737
+assert_return(() => invoke($245, `f`, []), [value("f32", -340282350000000000000000000000000000000)]);
+
+// ./test/core/const.wast:740
+let $246 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))`);
+
+// ./test/core/const.wast:741
+assert_return(
+  () => invoke($246, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/const.wast:742
+let $247 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))`);
+
+// ./test/core/const.wast:743
+assert_return(
+  () => invoke($247, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/const.wast:744
+let $248 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))`);
+
+// ./test/core/const.wast:745
+assert_return(
+  () => invoke($248, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:746
+let $249 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))`);
+
+// ./test/core/const.wast:747
+assert_return(
+  () => invoke($249, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:748
+let $250 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))`);
+
+// ./test/core/const.wast:749
+assert_return(
+  () => invoke($250, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:750
+let $251 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))`);
+
+// ./test/core/const.wast:751
+assert_return(
+  () => invoke($251, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:752
+let $252 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))`);
+
+// ./test/core/const.wast:753
+assert_return(
+  () => invoke($252, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:754
+let $253 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))`);
+
+// ./test/core/const.wast:755
+assert_return(
+  () => invoke($253, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:756
+let $254 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))`);
+
+// ./test/core/const.wast:757
+assert_return(
+  () => invoke($254, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:758
+let $255 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))`);
+
+// ./test/core/const.wast:759
+assert_return(
+  () => invoke($255, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:760
+let $256 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))`);
+
+// ./test/core/const.wast:761
+assert_return(
+  () => invoke($256, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:762
+let $257 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))`);
+
+// ./test/core/const.wast:763
+assert_return(
+  () => invoke($257, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:764
+let $258 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))`);
+
+// ./test/core/const.wast:765
+assert_return(
+  () => invoke($258, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:766
+let $259 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))`);
+
+// ./test/core/const.wast:767
+assert_return(
+  () => invoke($259, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:768
+let $260 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))`);
+
+// ./test/core/const.wast:769
+assert_return(
+  () => invoke($260, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:770
+let $261 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))`);
+
+// ./test/core/const.wast:771
+assert_return(
+  () => invoke($261, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:772
+let $262 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))`);
+
+// ./test/core/const.wast:773
+assert_return(
+  () => invoke($262, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:774
+let $263 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))`);
+
+// ./test/core/const.wast:775
+assert_return(
+  () => invoke($263, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:776
+let $264 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))`);
+
+// ./test/core/const.wast:777
+assert_return(
+  () => invoke($264, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:778
+let $265 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))`);
+
+// ./test/core/const.wast:779
+assert_return(
+  () => invoke($265, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:780
+let $266 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))`);
+
+// ./test/core/const.wast:781
+assert_return(
+  () => invoke($266, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:782
+let $267 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))`);
+
+// ./test/core/const.wast:783
+assert_return(
+  () => invoke($267, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:784
+let $268 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))`);
+
+// ./test/core/const.wast:785
+assert_return(
+  () => invoke($268, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:786
+let $269 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))`);
+
+// ./test/core/const.wast:787
+assert_return(
+  () => invoke($269, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:788
+let $270 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))`);
+
+// ./test/core/const.wast:789
+assert_return(
+  () => invoke($270, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/const.wast:790
+let $271 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))`);
+
+// ./test/core/const.wast:791
+assert_return(
+  () => invoke($271, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/const.wast:793
+let $272 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))`);
+
+// ./test/core/const.wast:794
+assert_return(
+  () => invoke($272, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/const.wast:795
+let $273 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))`);
+
+// ./test/core/const.wast:796
+assert_return(
+  () => invoke($273, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/const.wast:797
+let $274 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))`);
+
+// ./test/core/const.wast:798
+assert_return(
+  () => invoke($274, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:799
+let $275 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))`);
+
+// ./test/core/const.wast:800
+assert_return(
+  () => invoke($275, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:801
+let $276 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))`);
+
+// ./test/core/const.wast:802
+assert_return(
+  () => invoke($276, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:803
+let $277 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))`);
+
+// ./test/core/const.wast:804
+assert_return(
+  () => invoke($277, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:805
+let $278 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))`);
+
+// ./test/core/const.wast:806
+assert_return(
+  () => invoke($278, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:807
+let $279 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))`);
+
+// ./test/core/const.wast:808
+assert_return(
+  () => invoke($279, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:809
+let $280 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))`);
+
+// ./test/core/const.wast:810
+assert_return(
+  () => invoke($280, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:811
+let $281 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))`);
+
+// ./test/core/const.wast:812
+assert_return(
+  () => invoke($281, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:813
+let $282 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))`);
+
+// ./test/core/const.wast:814
+assert_return(
+  () => invoke($282, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:815
+let $283 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))`);
+
+// ./test/core/const.wast:816
+assert_return(
+  () => invoke($283, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/const.wast:817
+let $284 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))`);
+
+// ./test/core/const.wast:818
+assert_return(
+  () => invoke($284, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:819
+let $285 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))`);
+
+// ./test/core/const.wast:820
+assert_return(
+  () => invoke($285, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:821
+let $286 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))`);
+
+// ./test/core/const.wast:822
+assert_return(
+  () => invoke($286, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:823
+let $287 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))`);
+
+// ./test/core/const.wast:824
+assert_return(
+  () => invoke($287, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:825
+let $288 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))`);
+
+// ./test/core/const.wast:826
+assert_return(
+  () => invoke($288, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:827
+let $289 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))`);
+
+// ./test/core/const.wast:828
+assert_return(
+  () => invoke($289, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:829
+let $290 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))`);
+
+// ./test/core/const.wast:830
+assert_return(
+  () => invoke($290, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:831
+let $291 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))`);
+
+// ./test/core/const.wast:832
+assert_return(
+  () => invoke($291, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:833
+let $292 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))`);
+
+// ./test/core/const.wast:834
+assert_return(
+  () => invoke($292, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:835
+let $293 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))`);
+
+// ./test/core/const.wast:836
+assert_return(
+  () => invoke($293, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:837
+let $294 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))`);
+
+// ./test/core/const.wast:838
+assert_return(
+  () => invoke($294, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:839
+let $295 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))`);
+
+// ./test/core/const.wast:840
+assert_return(
+  () => invoke($295, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/const.wast:841
+let $296 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))`);
+
+// ./test/core/const.wast:842
+assert_return(
+  () => invoke($296, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/const.wast:843
+let $297 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))`);
+
+// ./test/core/const.wast:844
+assert_return(
+  () => invoke($297, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/const.wast:846
+let $298 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))`);
+
+// ./test/core/const.wast:847
+assert_return(
+  () => invoke($298, `f`, []),
+  [
+    value("f64", 5357543035931337000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:848
+let $299 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))`);
+
+// ./test/core/const.wast:849
+assert_return(
+  () => invoke($299, `f`, []),
+  [
+    value("f64", -5357543035931337000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:850
+let $300 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))`);
+
+// ./test/core/const.wast:851
+assert_return(
+  () => invoke($300, `f`, []),
+  [
+    value("f64", 5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:852
+let $301 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))`);
+
+// ./test/core/const.wast:853
+assert_return(
+  () => invoke($301, `f`, []),
+  [
+    value("f64", -5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:854
+let $302 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))`);
+
+// ./test/core/const.wast:855
+assert_return(
+  () => invoke($302, `f`, []),
+  [
+    value("f64", 5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:856
+let $303 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))`);
+
+// ./test/core/const.wast:857
+assert_return(
+  () => invoke($303, `f`, []),
+  [
+    value("f64", -5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:858
+let $304 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))`);
+
+// ./test/core/const.wast:859
+assert_return(
+  () => invoke($304, `f`, []),
+  [
+    value("f64", 5357543035931339000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:860
+let $305 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))`);
+
+// ./test/core/const.wast:861
+assert_return(
+  () => invoke($305, `f`, []),
+  [
+    value("f64", -5357543035931339000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:864
+let $306 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p+600)))`);
+
+// ./test/core/const.wast:865
+assert_return(
+  () => invoke($306, `f`, []),
+  [
+    value("f64", 4149515568880993000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:866
+let $307 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p+600)))`);
+
+// ./test/core/const.wast:867
+assert_return(
+  () => invoke($307, `f`, []),
+  [
+    value("f64", -4149515568880993000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:868
+let $308 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p+600)))`);
+
+// ./test/core/const.wast:869
+assert_return(
+  () => invoke($308, `f`, []),
+  [
+    value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:870
+let $309 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p+600)))`);
+
+// ./test/core/const.wast:871
+assert_return(
+  () => invoke($309, `f`, []),
+  [
+    value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:872
+let $310 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp+600)))`);
+
+// ./test/core/const.wast:873
+assert_return(
+  () => invoke($310, `f`, []),
+  [
+    value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:874
+let $311 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp+600)))`);
+
+// ./test/core/const.wast:875
+assert_return(
+  () => invoke($311, `f`, []),
+  [
+    value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:876
+let $312 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p+600)))`);
+
+// ./test/core/const.wast:877
+assert_return(
+  () => invoke($312, `f`, []),
+  [
+    value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:878
+let $313 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p+600)))`);
+
+// ./test/core/const.wast:879
+assert_return(
+  () => invoke($313, `f`, []),
+  [
+    value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:880
+let $314 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p+600)))`);
+
+// ./test/core/const.wast:881
+assert_return(
+  () => invoke($314, `f`, []),
+  [
+    value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:882
+let $315 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p+600)))`);
+
+// ./test/core/const.wast:883
+assert_return(
+  () => invoke($315, `f`, []),
+  [
+    value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:884
+let $316 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp+600)))`);
+
+// ./test/core/const.wast:885
+assert_return(
+  () => invoke($316, `f`, []),
+  [
+    value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:886
+let $317 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp+600)))`);
+
+// ./test/core/const.wast:887
+assert_return(
+  () => invoke($317, `f`, []),
+  [
+    value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:888
+let $318 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p+600)))`);
+
+// ./test/core/const.wast:889
+assert_return(
+  () => invoke($318, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:890
+let $319 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p+600)))`);
+
+// ./test/core/const.wast:891
+assert_return(
+  () => invoke($319, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:892
+let $320 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p+600)))`);
+
+// ./test/core/const.wast:893
+assert_return(
+  () => invoke($320, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:894
+let $321 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p+600)))`);
+
+// ./test/core/const.wast:895
+assert_return(
+  () => invoke($321, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:896
+let $322 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp+600)))`);
+
+// ./test/core/const.wast:897
+assert_return(
+  () => invoke($322, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:898
+let $323 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp+600)))`);
+
+// ./test/core/const.wast:899
+assert_return(
+  () => invoke($323, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:900
+let $324 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p+600)))`);
+
+// ./test/core/const.wast:901
+assert_return(
+  () => invoke($324, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:902
+let $325 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p+600)))`);
+
+// ./test/core/const.wast:903
+assert_return(
+  () => invoke($325, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:904
+let $326 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p+600)))`);
+
+// ./test/core/const.wast:905
+assert_return(
+  () => invoke($326, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:906
+let $327 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p+600)))`);
+
+// ./test/core/const.wast:907
+assert_return(
+  () => invoke($327, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:908
+let $328 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp+600)))`);
+
+// ./test/core/const.wast:909
+assert_return(
+  () => invoke($328, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:910
+let $329 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp+600)))`);
+
+// ./test/core/const.wast:911
+assert_return(
+  () => invoke($329, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:912
+let $330 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000000p+600)))`);
+
+// ./test/core/const.wast:913
+assert_return(
+  () => invoke($330, `f`, []),
+  [
+    value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:914
+let $331 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000000p+600)))`);
+
+// ./test/core/const.wast:915
+assert_return(
+  () => invoke($331, `f`, []),
+  [
+    value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:916
+let $332 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p+600)))`);
+
+// ./test/core/const.wast:917
+assert_return(
+  () => invoke($332, `f`, []),
+  [
+    value("f64", 4149515568880996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:918
+let $333 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p+600)))`);
+
+// ./test/core/const.wast:919
+assert_return(
+  () => invoke($333, `f`, []),
+  [
+    value("f64", -4149515568880996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:921
+let $334 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000000)))`);
+
+// ./test/core/const.wast:922
+assert_return(() => invoke($334, `f`, []), [value("f64", 158456325028528680000000000000)]);
+
+// ./test/core/const.wast:923
+let $335 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000000)))`);
+
+// ./test/core/const.wast:924
+assert_return(() => invoke($335, `f`, []), [value("f64", -158456325028528680000000000000)]);
+
+// ./test/core/const.wast:925
+let $336 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000001)))`);
+
+// ./test/core/const.wast:926
+assert_return(() => invoke($336, `f`, []), [value("f64", 158456325028528700000000000000)]);
+
+// ./test/core/const.wast:927
+let $337 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000001)))`);
+
+// ./test/core/const.wast:928
+assert_return(() => invoke($337, `f`, []), [value("f64", -158456325028528700000000000000)]);
+
+// ./test/core/const.wast:929
+let $338 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x20000000000001fffffffffff)))`);
+
+// ./test/core/const.wast:930
+assert_return(() => invoke($338, `f`, []), [value("f64", 158456325028528700000000000000)]);
+
+// ./test/core/const.wast:931
+let $339 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x20000000000001fffffffffff)))`);
+
+// ./test/core/const.wast:932
+assert_return(() => invoke($339, `f`, []), [value("f64", -158456325028528700000000000000)]);
+
+// ./test/core/const.wast:933
+let $340 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000000)))`);
+
+// ./test/core/const.wast:934
+assert_return(() => invoke($340, `f`, []), [value("f64", 158456325028528700000000000000)]);
+
+// ./test/core/const.wast:935
+let $341 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000000)))`);
+
+// ./test/core/const.wast:936
+assert_return(() => invoke($341, `f`, []), [value("f64", -158456325028528700000000000000)]);
+
+// ./test/core/const.wast:937
+let $342 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000001)))`);
+
+// ./test/core/const.wast:938
+assert_return(() => invoke($342, `f`, []), [value("f64", 158456325028528700000000000000)]);
+
+// ./test/core/const.wast:939
+let $343 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000001)))`);
+
+// ./test/core/const.wast:940
+assert_return(() => invoke($343, `f`, []), [value("f64", -158456325028528700000000000000)]);
+
+// ./test/core/const.wast:941
+let $344 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x20000000000002fffffffffff)))`);
+
+// ./test/core/const.wast:942
+assert_return(() => invoke($344, `f`, []), [value("f64", 158456325028528700000000000000)]);
+
+// ./test/core/const.wast:943
+let $345 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x20000000000002fffffffffff)))`);
+
+// ./test/core/const.wast:944
+assert_return(() => invoke($345, `f`, []), [value("f64", -158456325028528700000000000000)]);
+
+// ./test/core/const.wast:945
+let $346 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000000)))`);
+
+// ./test/core/const.wast:946
+assert_return(() => invoke($346, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:947
+let $347 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000000)))`);
+
+// ./test/core/const.wast:948
+assert_return(() => invoke($347, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:949
+let $348 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000001)))`);
+
+// ./test/core/const.wast:950
+assert_return(() => invoke($348, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:951
+let $349 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000001)))`);
+
+// ./test/core/const.wast:952
+assert_return(() => invoke($349, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:953
+let $350 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x20000000000003fffffffffff)))`);
+
+// ./test/core/const.wast:954
+assert_return(() => invoke($350, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:955
+let $351 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x20000000000003fffffffffff)))`);
+
+// ./test/core/const.wast:956
+assert_return(() => invoke($351, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:957
+let $352 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000000)))`);
+
+// ./test/core/const.wast:958
+assert_return(() => invoke($352, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:959
+let $353 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000000)))`);
+
+// ./test/core/const.wast:960
+assert_return(() => invoke($353, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:961
+let $354 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000001)))`);
+
+// ./test/core/const.wast:962
+assert_return(() => invoke($354, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:963
+let $355 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000001)))`);
+
+// ./test/core/const.wast:964
+assert_return(() => invoke($355, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:965
+let $356 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x20000000000004fffffffffff)))`);
+
+// ./test/core/const.wast:966
+assert_return(() => invoke($356, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:967
+let $357 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x20000000000004fffffffffff)))`);
+
+// ./test/core/const.wast:968
+assert_return(() => invoke($357, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:969
+let $358 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000000)))`);
+
+// ./test/core/const.wast:970
+assert_return(() => invoke($358, `f`, []), [value("f64", 158456325028528750000000000000)]);
+
+// ./test/core/const.wast:971
+let $359 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000000)))`);
+
+// ./test/core/const.wast:972
+assert_return(() => invoke($359, `f`, []), [value("f64", -158456325028528750000000000000)]);
+
+// ./test/core/const.wast:973
+let $360 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000001)))`);
+
+// ./test/core/const.wast:974
+assert_return(() => invoke($360, `f`, []), [value("f64", 158456325028528780000000000000)]);
+
+// ./test/core/const.wast:975
+let $361 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000001)))`);
+
+// ./test/core/const.wast:976
+assert_return(() => invoke($361, `f`, []), [value("f64", -158456325028528780000000000000)]);
+
+// ./test/core/const.wast:978
+let $362 = instantiate(`(module (func (export "f") (result f64) (f64.const +1152921504606847104)))`);
+
+// ./test/core/const.wast:979
+assert_return(() => invoke($362, `f`, []), [value("f64", 1152921504606847000)]);
+
+// ./test/core/const.wast:980
+let $363 = instantiate(`(module (func (export "f") (result f64) (f64.const -1152921504606847104)))`);
+
+// ./test/core/const.wast:981
+assert_return(() => invoke($363, `f`, []), [value("f64", -1152921504606847000)]);
+
+// ./test/core/const.wast:982
+let $364 = instantiate(`(module (func (export "f") (result f64) (f64.const +1152921504606847105)))`);
+
+// ./test/core/const.wast:983
+assert_return(() => invoke($364, `f`, []), [value("f64", 1152921504606847200)]);
+
+// ./test/core/const.wast:984
+let $365 = instantiate(`(module (func (export "f") (result f64) (f64.const -1152921504606847105)))`);
+
+// ./test/core/const.wast:985
+assert_return(() => invoke($365, `f`, []), [value("f64", -1152921504606847200)]);
+
+// ./test/core/const.wast:986
+let $366 = instantiate(`(module (func (export "f") (result f64) (f64.const +1152921504606847359)))`);
+
+// ./test/core/const.wast:987
+assert_return(() => invoke($366, `f`, []), [value("f64", 1152921504606847200)]);
+
+// ./test/core/const.wast:988
+let $367 = instantiate(`(module (func (export "f") (result f64) (f64.const -1152921504606847359)))`);
+
+// ./test/core/const.wast:989
+assert_return(() => invoke($367, `f`, []), [value("f64", -1152921504606847200)]);
+
+// ./test/core/const.wast:990
+let $368 = instantiate(`(module (func (export "f") (result f64) (f64.const +1152921504606847360)))`);
+
+// ./test/core/const.wast:991
+assert_return(() => invoke($368, `f`, []), [value("f64", 1152921504606847500)]);
+
+// ./test/core/const.wast:992
+let $369 = instantiate(`(module (func (export "f") (result f64) (f64.const -1152921504606847360)))`);
+
+// ./test/core/const.wast:993
+assert_return(() => invoke($369, `f`, []), [value("f64", -1152921504606847500)]);
+
+// ./test/core/const.wast:996
+let $370 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000000p-1022)))`);
+
+// ./test/core/const.wast:997
+assert_return(() => invoke($370, `f`, []), [value("f64", 0)]);
+
+// ./test/core/const.wast:998
+let $371 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000000p-1022)))`);
+
+// ./test/core/const.wast:999
+assert_return(() => invoke($371, `f`, []), [value("f64", -0)]);
+
+// ./test/core/const.wast:1000
+let $372 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000001p-1022)))`);
+
+// ./test/core/const.wast:1001
+assert_return(
+  () => invoke($372, `f`, []),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1002
+let $373 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000001p-1022)))`);
+
+// ./test/core/const.wast:1003
+assert_return(
+  () => invoke($373, `f`, []),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1004
+let $374 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.0000000000000fffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1005
+assert_return(
+  () => invoke($374, `f`, []),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1006
+let $375 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.0000000000000fffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1007
+assert_return(
+  () => invoke($375, `f`, []),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1008
+let $376 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000000p-1022)))`);
+
+// ./test/core/const.wast:1009
+assert_return(
+  () => invoke($376, `f`, []),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1010
+let $377 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000000p-1022)))`);
+
+// ./test/core/const.wast:1011
+assert_return(
+  () => invoke($377, `f`, []),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1012
+let $378 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000001p-1022)))`);
+
+// ./test/core/const.wast:1013
+assert_return(
+  () => invoke($378, `f`, []),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1014
+let $379 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000001p-1022)))`);
+
+// ./test/core/const.wast:1015
+assert_return(
+  () => invoke($379, `f`, []),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1016
+let $380 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.00000000000017ffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1017
+assert_return(
+  () => invoke($380, `f`, []),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1018
+let $381 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.00000000000017ffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1019
+assert_return(
+  () => invoke($381, `f`, []),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/const.wast:1020
+let $382 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000000p-1022)))`);
+
+// ./test/core/const.wast:1021
+assert_return(
+  () => invoke($382, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1022
+let $383 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000000p-1022)))`);
+
+// ./test/core/const.wast:1023
+assert_return(
+  () => invoke($383, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1024
+let $384 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000001p-1022)))`);
+
+// ./test/core/const.wast:1025
+assert_return(
+  () => invoke($384, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1026
+let $385 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000001p-1022)))`);
+
+// ./test/core/const.wast:1027
+assert_return(
+  () => invoke($385, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1028
+let $386 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.0000000000001fffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1029
+assert_return(
+  () => invoke($386, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1030
+let $387 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.0000000000001fffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1031
+assert_return(
+  () => invoke($387, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1032
+let $388 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000000p-1022)))`);
+
+// ./test/core/const.wast:1033
+assert_return(
+  () => invoke($388, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1034
+let $389 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000000p-1022)))`);
+
+// ./test/core/const.wast:1035
+assert_return(
+  () => invoke($389, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1036
+let $390 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000001p-1022)))`);
+
+// ./test/core/const.wast:1037
+assert_return(
+  () => invoke($390, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1038
+let $391 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000001p-1022)))`);
+
+// ./test/core/const.wast:1039
+assert_return(
+  () => invoke($391, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1040
+let $392 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.00000000000027ffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1041
+assert_return(
+  () => invoke($392, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1042
+let $393 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.00000000000027ffffffffffp-1022)))`);
+
+// ./test/core/const.wast:1043
+assert_return(
+  () => invoke($393, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1044
+let $394 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x0.000000000000280000000000p-1022)))`);
+
+// ./test/core/const.wast:1045
+assert_return(
+  () => invoke($394, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1046
+let $395 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x0.000000000000280000000000p-1022)))`);
+
+// ./test/core/const.wast:1047
+assert_return(
+  () => invoke($395, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/const.wast:1048
+let $396 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-1022)))`);
+
+// ./test/core/const.wast:1049
+assert_return(
+  () => invoke($396, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507203),
+  ],
+);
+
+// ./test/core/const.wast:1050
+let $397 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-1022)))`);
+
+// ./test/core/const.wast:1051
+assert_return(
+  () => invoke($397, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507203),
+  ],
+);
+
+// ./test/core/const.wast:1054
+let $398 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff4p1023)))`);
+
+// ./test/core/const.wast:1055
+assert_return(
+  () => invoke($398, `f`, []),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:1056
+let $399 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff4p1023)))`);
+
+// ./test/core/const.wast:1057
+assert_return(
+  () => invoke($399, `f`, []),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:1058
+let $400 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff7ffffffp1023)))`);
+
+// ./test/core/const.wast:1059
+assert_return(
+  () => invoke($400, `f`, []),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/const.wast:1060
+let $401 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff7ffffffp1023)))`);
+
+// ./test/core/const.wast:1061
+assert_return(
+  () => invoke($401, `f`, []),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/conversions.wast.js b/js/src/jit-test/tests/wasm/spec/spec/conversions.wast.js
new file mode 100644
index 0000000000..b845545c23
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/conversions.wast.js
@@ -0,0 +1,3109 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/conversions.wast
+
+// ./test/core/conversions.wast:1
+let $0 = instantiate(`(module
+  (func (export "i64.extend_i32_s") (param $$x i32) (result i64) (i64.extend_i32_s (local.get $$x)))
+  (func (export "i64.extend_i32_u") (param $$x i32) (result i64) (i64.extend_i32_u (local.get $$x)))
+  (func (export "i32.wrap_i64") (param $$x i64) (result i32) (i32.wrap_i64 (local.get $$x)))
+  (func (export "i32.trunc_f32_s") (param $$x f32) (result i32) (i32.trunc_f32_s (local.get $$x)))
+  (func (export "i32.trunc_f32_u") (param $$x f32) (result i32) (i32.trunc_f32_u (local.get $$x)))
+  (func (export "i32.trunc_f64_s") (param $$x f64) (result i32) (i32.trunc_f64_s (local.get $$x)))
+  (func (export "i32.trunc_f64_u") (param $$x f64) (result i32) (i32.trunc_f64_u (local.get $$x)))
+  (func (export "i64.trunc_f32_s") (param $$x f32) (result i64) (i64.trunc_f32_s (local.get $$x)))
+  (func (export "i64.trunc_f32_u") (param $$x f32) (result i64) (i64.trunc_f32_u (local.get $$x)))
+  (func (export "i64.trunc_f64_s") (param $$x f64) (result i64) (i64.trunc_f64_s (local.get $$x)))
+  (func (export "i64.trunc_f64_u") (param $$x f64) (result i64) (i64.trunc_f64_u (local.get $$x)))
+  (func (export "i32.trunc_sat_f32_s") (param $$x f32) (result i32) (i32.trunc_sat_f32_s (local.get $$x)))
+  (func (export "i32.trunc_sat_f32_u") (param $$x f32) (result i32) (i32.trunc_sat_f32_u (local.get $$x)))
+  (func (export "i32.trunc_sat_f64_s") (param $$x f64) (result i32) (i32.trunc_sat_f64_s (local.get $$x)))
+  (func (export "i32.trunc_sat_f64_u") (param $$x f64) (result i32) (i32.trunc_sat_f64_u (local.get $$x)))
+  (func (export "i64.trunc_sat_f32_s") (param $$x f32) (result i64) (i64.trunc_sat_f32_s (local.get $$x)))
+  (func (export "i64.trunc_sat_f32_u") (param $$x f32) (result i64) (i64.trunc_sat_f32_u (local.get $$x)))
+  (func (export "i64.trunc_sat_f64_s") (param $$x f64) (result i64) (i64.trunc_sat_f64_s (local.get $$x)))
+  (func (export "i64.trunc_sat_f64_u") (param $$x f64) (result i64) (i64.trunc_sat_f64_u (local.get $$x)))
+  (func (export "f32.convert_i32_s") (param $$x i32) (result f32) (f32.convert_i32_s (local.get $$x)))
+  (func (export "f32.convert_i64_s") (param $$x i64) (result f32) (f32.convert_i64_s (local.get $$x)))
+  (func (export "f64.convert_i32_s") (param $$x i32) (result f64) (f64.convert_i32_s (local.get $$x)))
+  (func (export "f64.convert_i64_s") (param $$x i64) (result f64) (f64.convert_i64_s (local.get $$x)))
+  (func (export "f32.convert_i32_u") (param $$x i32) (result f32) (f32.convert_i32_u (local.get $$x)))
+  (func (export "f32.convert_i64_u") (param $$x i64) (result f32) (f32.convert_i64_u (local.get $$x)))
+  (func (export "f64.convert_i32_u") (param $$x i32) (result f64) (f64.convert_i32_u (local.get $$x)))
+  (func (export "f64.convert_i64_u") (param $$x i64) (result f64) (f64.convert_i64_u (local.get $$x)))
+  (func (export "f64.promote_f32") (param $$x f32) (result f64) (f64.promote_f32 (local.get $$x)))
+  (func (export "f32.demote_f64") (param $$x f64) (result f32) (f32.demote_f64 (local.get $$x)))
+  (func (export "f32.reinterpret_i32") (param $$x i32) (result f32) (f32.reinterpret_i32 (local.get $$x)))
+  (func (export "f64.reinterpret_i64") (param $$x i64) (result f64) (f64.reinterpret_i64 (local.get $$x)))
+  (func (export "i32.reinterpret_f32") (param $$x f32) (result i32) (i32.reinterpret_f32 (local.get $$x)))
+  (func (export "i64.reinterpret_f64") (param $$x f64) (result i64) (i64.reinterpret_f64 (local.get $$x)))
+)`);
+
+// ./test/core/conversions.wast:37
+assert_return(() => invoke($0, `i64.extend_i32_s`, [0]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:38
+assert_return(() => invoke($0, `i64.extend_i32_s`, [10000]), [value("i64", 10000n)]);
+
+// ./test/core/conversions.wast:39
+assert_return(() => invoke($0, `i64.extend_i32_s`, [-10000]), [value("i64", -10000n)]);
+
+// ./test/core/conversions.wast:40
+assert_return(() => invoke($0, `i64.extend_i32_s`, [-1]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:41
+assert_return(() => invoke($0, `i64.extend_i32_s`, [2147483647]), [value("i64", 2147483647n)]);
+
+// ./test/core/conversions.wast:42
+assert_return(() => invoke($0, `i64.extend_i32_s`, [-2147483648]), [value("i64", -2147483648n)]);
+
+// ./test/core/conversions.wast:44
+assert_return(() => invoke($0, `i64.extend_i32_u`, [0]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:45
+assert_return(() => invoke($0, `i64.extend_i32_u`, [10000]), [value("i64", 10000n)]);
+
+// ./test/core/conversions.wast:46
+assert_return(() => invoke($0, `i64.extend_i32_u`, [-10000]), [value("i64", 4294957296n)]);
+
+// ./test/core/conversions.wast:47
+assert_return(() => invoke($0, `i64.extend_i32_u`, [-1]), [value("i64", 4294967295n)]);
+
+// ./test/core/conversions.wast:48
+assert_return(() => invoke($0, `i64.extend_i32_u`, [2147483647]), [value("i64", 2147483647n)]);
+
+// ./test/core/conversions.wast:49
+assert_return(() => invoke($0, `i64.extend_i32_u`, [-2147483648]), [value("i64", 2147483648n)]);
+
+// ./test/core/conversions.wast:51
+assert_return(() => invoke($0, `i32.wrap_i64`, [-1n]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:52
+assert_return(() => invoke($0, `i32.wrap_i64`, [-100000n]), [value("i32", -100000)]);
+
+// ./test/core/conversions.wast:53
+assert_return(() => invoke($0, `i32.wrap_i64`, [2147483648n]), [value("i32", -2147483648)]);
+
+// ./test/core/conversions.wast:54
+assert_return(() => invoke($0, `i32.wrap_i64`, [-2147483649n]), [value("i32", 2147483647)]);
+
+// ./test/core/conversions.wast:55
+assert_return(() => invoke($0, `i32.wrap_i64`, [-4294967296n]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:56
+assert_return(() => invoke($0, `i32.wrap_i64`, [-4294967297n]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:57
+assert_return(() => invoke($0, `i32.wrap_i64`, [-4294967295n]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:58
+assert_return(() => invoke($0, `i32.wrap_i64`, [0n]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:59
+assert_return(() => invoke($0, `i32.wrap_i64`, [1311768467463790320n]), [value("i32", -1698898192)]);
+
+// ./test/core/conversions.wast:60
+assert_return(() => invoke($0, `i32.wrap_i64`, [4294967295n]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:61
+assert_return(() => invoke($0, `i32.wrap_i64`, [4294967296n]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:62
+assert_return(() => invoke($0, `i32.wrap_i64`, [4294967297n]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:64
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:65
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:66
+assert_return(
+  () => invoke($0, `i32.trunc_f32_s`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:67
+assert_return(
+  () => invoke($0, `i32.trunc_f32_s`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:68
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:69
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:70
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:71
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:72
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -1.1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:73
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -1.5)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:74
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -1.9)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:75
+assert_return(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -2)]), [value("i32", -2)]);
+
+// ./test/core/conversions.wast:76
+assert_return(
+  () => invoke($0, `i32.trunc_f32_s`, [value("f32", 2147483500)]),
+  [value("i32", 2147483520)],
+);
+
+// ./test/core/conversions.wast:77
+assert_return(
+  () => invoke($0, `i32.trunc_f32_s`, [value("f32", -2147483600)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:78
+assert_trap(() => invoke($0, `i32.trunc_f32_s`, [value("f32", 2147483600)]), `integer overflow`);
+
+// ./test/core/conversions.wast:79
+assert_trap(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -2147484000)]), `integer overflow`);
+
+// ./test/core/conversions.wast:80
+assert_trap(() => invoke($0, `i32.trunc_f32_s`, [value("f32", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:81
+assert_trap(() => invoke($0, `i32.trunc_f32_s`, [value("f32", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:82
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:83
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:84
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:85
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:87
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:88
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:89
+assert_return(
+  () => invoke($0, `i32.trunc_f32_u`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:90
+assert_return(
+  () => invoke($0, `i32.trunc_f32_u`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:91
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:92
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:93
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:94
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 1.9)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:95
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 2)]), [value("i32", 2)]);
+
+// ./test/core/conversions.wast:96
+assert_return(
+  () => invoke($0, `i32.trunc_f32_u`, [value("f32", 2147483600)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:97
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 4294967000)]), [value("i32", -256)]);
+
+// ./test/core/conversions.wast:98
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", -0.9)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:99
+assert_return(() => invoke($0, `i32.trunc_f32_u`, [value("f32", -0.99999994)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:100
+assert_trap(() => invoke($0, `i32.trunc_f32_u`, [value("f32", 4294967300)]), `integer overflow`);
+
+// ./test/core/conversions.wast:101
+assert_trap(() => invoke($0, `i32.trunc_f32_u`, [value("f32", -1)]), `integer overflow`);
+
+// ./test/core/conversions.wast:102
+assert_trap(() => invoke($0, `i32.trunc_f32_u`, [value("f32", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:103
+assert_trap(() => invoke($0, `i32.trunc_f32_u`, [value("f32", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:104
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:105
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:106
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:107
+assert_trap(
+  () => invoke($0, `i32.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:109
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:110
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:111
+assert_return(
+  () => invoke($0, `i32.trunc_f64_s`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:112
+assert_return(
+  () => invoke($0, `i32.trunc_f64_s`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:113
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:114
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:115
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:116
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:117
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -1.1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:118
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -1.5)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:119
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -1.9)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:120
+assert_return(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -2)]), [value("i32", -2)]);
+
+// ./test/core/conversions.wast:121
+assert_return(
+  () => invoke($0, `i32.trunc_f64_s`, [value("f64", 2147483647)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:122
+assert_return(
+  () => invoke($0, `i32.trunc_f64_s`, [value("f64", -2147483648)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:123
+assert_return(
+  () => invoke($0, `i32.trunc_f64_s`, [value("f64", -2147483648.9)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:124
+assert_return(
+  () => invoke($0, `i32.trunc_f64_s`, [value("f64", 2147483647.9)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:125
+assert_trap(() => invoke($0, `i32.trunc_f64_s`, [value("f64", 2147483648)]), `integer overflow`);
+
+// ./test/core/conversions.wast:126
+assert_trap(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -2147483649)]), `integer overflow`);
+
+// ./test/core/conversions.wast:127
+assert_trap(() => invoke($0, `i32.trunc_f64_s`, [value("f64", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:128
+assert_trap(() => invoke($0, `i32.trunc_f64_s`, [value("f64", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:129
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:130
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:131
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:132
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:134
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:135
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:136
+assert_return(
+  () => invoke($0, `i32.trunc_f64_u`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:137
+assert_return(
+  () => invoke($0, `i32.trunc_f64_u`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:138
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:139
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:140
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:141
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 1.9)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:142
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 2)]), [value("i32", 2)]);
+
+// ./test/core/conversions.wast:143
+assert_return(
+  () => invoke($0, `i32.trunc_f64_u`, [value("f64", 2147483648)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:144
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 4294967295)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:145
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", -0.9)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:146
+assert_return(
+  () => invoke($0, `i32.trunc_f64_u`, [value("f64", -0.9999999999999999)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:147
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 100000000)]), [value("i32", 100000000)]);
+
+// ./test/core/conversions.wast:148
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", -0.9)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:149
+assert_return(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 4294967295.9)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:150
+assert_trap(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 4294967296)]), `integer overflow`);
+
+// ./test/core/conversions.wast:151
+assert_trap(() => invoke($0, `i32.trunc_f64_u`, [value("f64", -1)]), `integer overflow`);
+
+// ./test/core/conversions.wast:152
+assert_trap(() => invoke($0, `i32.trunc_f64_u`, [value("f64", 10000000000000000)]), `integer overflow`);
+
+// ./test/core/conversions.wast:153
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_u`, [value("f64", 1000000000000000000000000000000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:154
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_u`, [value("f64", 9223372036854776000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:155
+assert_trap(() => invoke($0, `i32.trunc_f64_u`, [value("f64", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:156
+assert_trap(() => invoke($0, `i32.trunc_f64_u`, [value("f64", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:157
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:158
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:159
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:160
+assert_trap(
+  () => invoke($0, `i32.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:162
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:163
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:164
+assert_return(
+  () => invoke($0, `i64.trunc_f32_s`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:165
+assert_return(
+  () => invoke($0, `i64.trunc_f32_s`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:166
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:167
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:168
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:169
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:170
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -1.1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:171
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -1.5)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:172
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -1.9)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:173
+assert_return(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -2)]), [value("i64", -2n)]);
+
+// ./test/core/conversions.wast:174
+assert_return(
+  () => invoke($0, `i64.trunc_f32_s`, [value("f32", 4294967300)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:175
+assert_return(
+  () => invoke($0, `i64.trunc_f32_s`, [value("f32", -4294967300)]),
+  [value("i64", -4294967296n)],
+);
+
+// ./test/core/conversions.wast:176
+assert_return(
+  () => invoke($0, `i64.trunc_f32_s`, [value("f32", 9223371500000000000)]),
+  [value("i64", 9223371487098961920n)],
+);
+
+// ./test/core/conversions.wast:177
+assert_return(
+  () => invoke($0, `i64.trunc_f32_s`, [value("f32", -9223372000000000000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:178
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_s`, [value("f32", 9223372000000000000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:179
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_s`, [value("f32", -9223373000000000000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:180
+assert_trap(() => invoke($0, `i64.trunc_f32_s`, [value("f32", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:181
+assert_trap(() => invoke($0, `i64.trunc_f32_s`, [value("f32", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:182
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:183
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:184
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:185
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:187
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:188
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:189
+assert_return(
+  () => invoke($0, `i64.trunc_f32_u`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:190
+assert_return(
+  () => invoke($0, `i64.trunc_f32_u`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:191
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:192
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:193
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:194
+assert_return(
+  () => invoke($0, `i64.trunc_f32_u`, [value("f32", 4294967300)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:195
+assert_return(
+  () => invoke($0, `i64.trunc_f32_u`, [value("f32", 18446743000000000000)]),
+  [value("i64", -1099511627776n)],
+);
+
+// ./test/core/conversions.wast:196
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", -0.9)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:197
+assert_return(() => invoke($0, `i64.trunc_f32_u`, [value("f32", -0.99999994)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:198
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_u`, [value("f32", 18446744000000000000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:199
+assert_trap(() => invoke($0, `i64.trunc_f32_u`, [value("f32", -1)]), `integer overflow`);
+
+// ./test/core/conversions.wast:200
+assert_trap(() => invoke($0, `i64.trunc_f32_u`, [value("f32", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:201
+assert_trap(() => invoke($0, `i64.trunc_f32_u`, [value("f32", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:202
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:203
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:204
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:205
+assert_trap(
+  () => invoke($0, `i64.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:207
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:208
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:209
+assert_return(
+  () => invoke($0, `i64.trunc_f64_s`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:210
+assert_return(
+  () => invoke($0, `i64.trunc_f64_s`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:211
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:212
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:213
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:214
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:215
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -1.1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:216
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -1.5)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:217
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -1.9)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:218
+assert_return(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -2)]), [value("i64", -2n)]);
+
+// ./test/core/conversions.wast:219
+assert_return(
+  () => invoke($0, `i64.trunc_f64_s`, [value("f64", 4294967296)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:220
+assert_return(
+  () => invoke($0, `i64.trunc_f64_s`, [value("f64", -4294967296)]),
+  [value("i64", -4294967296n)],
+);
+
+// ./test/core/conversions.wast:221
+assert_return(
+  () => invoke($0, `i64.trunc_f64_s`, [value("f64", 9223372036854775000)]),
+  [value("i64", 9223372036854774784n)],
+);
+
+// ./test/core/conversions.wast:222
+assert_return(
+  () => invoke($0, `i64.trunc_f64_s`, [value("f64", -9223372036854776000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:223
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_s`, [value("f64", 9223372036854776000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:224
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_s`, [value("f64", -9223372036854778000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:225
+assert_trap(() => invoke($0, `i64.trunc_f64_s`, [value("f64", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:226
+assert_trap(() => invoke($0, `i64.trunc_f64_s`, [value("f64", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:227
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:228
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:229
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:230
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:232
+assert_return(() => invoke($0, `i64.trunc_f64_u`, [value("f64", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:233
+assert_return(() => invoke($0, `i64.trunc_f64_u`, [value("f64", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:234
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:235
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:236
+assert_return(() => invoke($0, `i64.trunc_f64_u`, [value("f64", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:237
+assert_return(() => invoke($0, `i64.trunc_f64_u`, [value("f64", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:238
+assert_return(() => invoke($0, `i64.trunc_f64_u`, [value("f64", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:239
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 4294967295)]),
+  [value("i64", 4294967295n)],
+);
+
+// ./test/core/conversions.wast:240
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 4294967296)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:241
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 18446744073709550000)]),
+  [value("i64", -2048n)],
+);
+
+// ./test/core/conversions.wast:242
+assert_return(() => invoke($0, `i64.trunc_f64_u`, [value("f64", -0.9)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:243
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", -0.9999999999999999)]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:244
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 100000000)]),
+  [value("i64", 100000000n)],
+);
+
+// ./test/core/conversions.wast:245
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 10000000000000000)]),
+  [value("i64", 10000000000000000n)],
+);
+
+// ./test/core/conversions.wast:246
+assert_return(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 9223372036854776000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:247
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_u`, [value("f64", 18446744073709552000)]),
+  `integer overflow`,
+);
+
+// ./test/core/conversions.wast:248
+assert_trap(() => invoke($0, `i64.trunc_f64_u`, [value("f64", -1)]), `integer overflow`);
+
+// ./test/core/conversions.wast:249
+assert_trap(() => invoke($0, `i64.trunc_f64_u`, [value("f64", Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:250
+assert_trap(() => invoke($0, `i64.trunc_f64_u`, [value("f64", -Infinity)]), `integer overflow`);
+
+// ./test/core/conversions.wast:251
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:252
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:253
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:254
+assert_trap(
+  () => invoke($0, `i64.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/conversions.wast:256
+assert_return(() => invoke($0, `f32.convert_i32_s`, [1]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:257
+assert_return(() => invoke($0, `f32.convert_i32_s`, [-1]), [value("f32", -1)]);
+
+// ./test/core/conversions.wast:258
+assert_return(() => invoke($0, `f32.convert_i32_s`, [0]), [value("f32", 0)]);
+
+// ./test/core/conversions.wast:259
+assert_return(() => invoke($0, `f32.convert_i32_s`, [2147483647]), [value("f32", 2147483600)]);
+
+// ./test/core/conversions.wast:260
+assert_return(() => invoke($0, `f32.convert_i32_s`, [-2147483648]), [value("f32", -2147483600)]);
+
+// ./test/core/conversions.wast:261
+assert_return(() => invoke($0, `f32.convert_i32_s`, [1234567890]), [value("f32", 1234568000)]);
+
+// ./test/core/conversions.wast:265
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:266
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:267
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:268
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:269
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:270
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:271
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:272
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:273
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -1.1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:274
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -1.5)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:275
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -1.9)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:276
+assert_return(() => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -2)]), [value("i32", -2)]);
+
+// ./test/core/conversions.wast:277
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", 2147483500)]),
+  [value("i32", 2147483520)],
+);
+
+// ./test/core/conversions.wast:278
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -2147483600)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:279
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", 2147483600)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:280
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -2147484000)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:281
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", Infinity)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:282
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [value("f32", -Infinity)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:283
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:284
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:285
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:286
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:288
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:289
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:290
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:291
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:292
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:293
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:294
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:295
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 1.9)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:296
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 2)]), [value("i32", 2)]);
+
+// ./test/core/conversions.wast:297
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 2147483600)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:298
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 4294967000)]), [value("i32", -256)]);
+
+// ./test/core/conversions.wast:299
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", -0.9)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:300
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", -0.99999994)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:301
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", 4294967300)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:302
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:303
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", Infinity)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:304
+assert_return(() => invoke($0, `i32.trunc_sat_f32_u`, [value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:305
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:306
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:307
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:308
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:310
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:311
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:312
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:313
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:314
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:315
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:316
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:317
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:318
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -1.1)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:319
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -1.5)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:320
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -1.9)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:321
+assert_return(() => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -2)]), [value("i32", -2)]);
+
+// ./test/core/conversions.wast:322
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", 2147483647)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:323
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -2147483648)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:324
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", 2147483648)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:325
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -2147483649)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:326
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", Infinity)]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/conversions.wast:327
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [value("f64", -Infinity)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:328
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:329
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:330
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:331
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:333
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:334
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:335
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:336
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:337
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:338
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 1.1)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:339
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 1.5)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:340
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 1.9)]), [value("i32", 1)]);
+
+// ./test/core/conversions.wast:341
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 2)]), [value("i32", 2)]);
+
+// ./test/core/conversions.wast:342
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 2147483648)]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/conversions.wast:343
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 4294967295)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:344
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", -0.9)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:345
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", -0.9999999999999999)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:346
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 100000000)]),
+  [value("i32", 100000000)],
+);
+
+// ./test/core/conversions.wast:347
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 4294967296)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:348
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:349
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 10000000000000000)]),
+  [value("i32", -1)],
+);
+
+// ./test/core/conversions.wast:350
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    value("f64", 1000000000000000000000000000000),
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/conversions.wast:351
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", 9223372036854776000)]),
+  [value("i32", -1)],
+);
+
+// ./test/core/conversions.wast:352
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", Infinity)]), [value("i32", -1)]);
+
+// ./test/core/conversions.wast:353
+assert_return(() => invoke($0, `i32.trunc_sat_f64_u`, [value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:354
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:355
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:356
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:357
+assert_return(
+  () => invoke($0, `i32.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/conversions.wast:359
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:360
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:361
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:362
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:363
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:364
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:365
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:366
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:367
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -1.1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:368
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -1.5)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:369
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -1.9)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:370
+assert_return(() => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -2)]), [value("i64", -2n)]);
+
+// ./test/core/conversions.wast:371
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 4294967300)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:372
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -4294967300)]),
+  [value("i64", -4294967296n)],
+);
+
+// ./test/core/conversions.wast:373
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 9223371500000000000)]),
+  [value("i64", 9223371487098961920n)],
+);
+
+// ./test/core/conversions.wast:374
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -9223372000000000000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:375
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", 9223372000000000000)]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/conversions.wast:376
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -9223373000000000000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:377
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", Infinity)]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/conversions.wast:378
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [value("f32", -Infinity)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:379
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:380
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:381
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:382
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_s`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:384
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:385
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:386
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:387
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:388
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:389
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:390
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:391
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 4294967300)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:392
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 18446743000000000000)]),
+  [value("i64", -1099511627776n)],
+);
+
+// ./test/core/conversions.wast:393
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", -0.9)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:394
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", -0.99999994)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:395
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", 18446744000000000000)]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/conversions.wast:396
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", -1)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:397
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", Infinity)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:398
+assert_return(() => invoke($0, `i64.trunc_sat_f32_u`, [value("f32", -Infinity)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:399
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:400
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:401
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:402
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f32_u`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:404
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:405
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:406
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:407
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:408
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:409
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:410
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:411
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:412
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -1.1)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:413
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -1.5)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:414
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -1.9)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:415
+assert_return(() => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -2)]), [value("i64", -2n)]);
+
+// ./test/core/conversions.wast:416
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 4294967296)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:417
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -4294967296)]),
+  [value("i64", -4294967296n)],
+);
+
+// ./test/core/conversions.wast:418
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 9223372036854775000)]),
+  [value("i64", 9223372036854774784n)],
+);
+
+// ./test/core/conversions.wast:419
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -9223372036854776000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:420
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", 9223372036854776000)]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/conversions.wast:421
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -9223372036854778000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:422
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", Infinity)]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/conversions.wast:423
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [value("f64", -Infinity)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:424
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:425
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:426
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:427
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:429
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:430
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", -0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:431
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:432
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:433
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:434
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 1.1)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:435
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 1.5)]), [value("i64", 1n)]);
+
+// ./test/core/conversions.wast:436
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 4294967295)]),
+  [value("i64", 4294967295n)],
+);
+
+// ./test/core/conversions.wast:437
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 4294967296)]),
+  [value("i64", 4294967296n)],
+);
+
+// ./test/core/conversions.wast:438
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 18446744073709550000)]),
+  [value("i64", -2048n)],
+);
+
+// ./test/core/conversions.wast:439
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", -0.9)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:440
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", -0.9999999999999999)]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:441
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 100000000)]),
+  [value("i64", 100000000n)],
+);
+
+// ./test/core/conversions.wast:442
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 10000000000000000)]),
+  [value("i64", 10000000000000000n)],
+);
+
+// ./test/core/conversions.wast:443
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 9223372036854776000)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:444
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", 18446744073709552000)]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/conversions.wast:445
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", -1)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:446
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", Infinity)]), [value("i64", -1n)]);
+
+// ./test/core/conversions.wast:447
+assert_return(() => invoke($0, `i64.trunc_sat_f64_u`, [value("f64", -Infinity)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:448
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:449
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:450
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:451
+assert_return(
+  () => invoke($0, `i64.trunc_sat_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/conversions.wast:454
+assert_return(() => invoke($0, `f32.convert_i32_s`, [16777217]), [value("f32", 16777216)]);
+
+// ./test/core/conversions.wast:455
+assert_return(() => invoke($0, `f32.convert_i32_s`, [-16777217]), [value("f32", -16777216)]);
+
+// ./test/core/conversions.wast:456
+assert_return(() => invoke($0, `f32.convert_i32_s`, [16777219]), [value("f32", 16777220)]);
+
+// ./test/core/conversions.wast:457
+assert_return(() => invoke($0, `f32.convert_i32_s`, [-16777219]), [value("f32", -16777220)]);
+
+// ./test/core/conversions.wast:459
+assert_return(() => invoke($0, `f32.convert_i64_s`, [1n]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:460
+assert_return(() => invoke($0, `f32.convert_i64_s`, [-1n]), [value("f32", -1)]);
+
+// ./test/core/conversions.wast:461
+assert_return(() => invoke($0, `f32.convert_i64_s`, [0n]), [value("f32", 0)]);
+
+// ./test/core/conversions.wast:462
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [9223372036854775807n]),
+  [value("f32", 9223372000000000000)],
+);
+
+// ./test/core/conversions.wast:463
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [-9223372036854775808n]),
+  [value("f32", -9223372000000000000)],
+);
+
+// ./test/core/conversions.wast:464
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [314159265358979n]),
+  [value("f32", 314159280000000)],
+);
+
+// ./test/core/conversions.wast:466
+assert_return(() => invoke($0, `f32.convert_i64_s`, [16777217n]), [value("f32", 16777216)]);
+
+// ./test/core/conversions.wast:467
+assert_return(() => invoke($0, `f32.convert_i64_s`, [-16777217n]), [value("f32", -16777216)]);
+
+// ./test/core/conversions.wast:468
+assert_return(() => invoke($0, `f32.convert_i64_s`, [16777219n]), [value("f32", 16777220)]);
+
+// ./test/core/conversions.wast:469
+assert_return(() => invoke($0, `f32.convert_i64_s`, [-16777219n]), [value("f32", -16777220)]);
+
+// ./test/core/conversions.wast:471
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [9223371212221054977n]),
+  [value("f32", 9223371500000000000)],
+);
+
+// ./test/core/conversions.wast:472
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [-9223371761976868863n]),
+  [value("f32", -9223371500000000000)],
+);
+
+// ./test/core/conversions.wast:473
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [9007199791611905n]),
+  [value("f32", 9007200000000000)],
+);
+
+// ./test/core/conversions.wast:474
+assert_return(
+  () => invoke($0, `f32.convert_i64_s`, [-9007199791611905n]),
+  [value("f32", -9007200000000000)],
+);
+
+// ./test/core/conversions.wast:476
+assert_return(() => invoke($0, `f64.convert_i32_s`, [1]), [value("f64", 1)]);
+
+// ./test/core/conversions.wast:477
+assert_return(() => invoke($0, `f64.convert_i32_s`, [-1]), [value("f64", -1)]);
+
+// ./test/core/conversions.wast:478
+assert_return(() => invoke($0, `f64.convert_i32_s`, [0]), [value("f64", 0)]);
+
+// ./test/core/conversions.wast:479
+assert_return(() => invoke($0, `f64.convert_i32_s`, [2147483647]), [value("f64", 2147483647)]);
+
+// ./test/core/conversions.wast:480
+assert_return(() => invoke($0, `f64.convert_i32_s`, [-2147483648]), [value("f64", -2147483648)]);
+
+// ./test/core/conversions.wast:481
+assert_return(() => invoke($0, `f64.convert_i32_s`, [987654321]), [value("f64", 987654321)]);
+
+// ./test/core/conversions.wast:483
+assert_return(() => invoke($0, `f64.convert_i64_s`, [1n]), [value("f64", 1)]);
+
+// ./test/core/conversions.wast:484
+assert_return(() => invoke($0, `f64.convert_i64_s`, [-1n]), [value("f64", -1)]);
+
+// ./test/core/conversions.wast:485
+assert_return(() => invoke($0, `f64.convert_i64_s`, [0n]), [value("f64", 0)]);
+
+// ./test/core/conversions.wast:486
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [9223372036854775807n]),
+  [value("f64", 9223372036854776000)],
+);
+
+// ./test/core/conversions.wast:487
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [-9223372036854775808n]),
+  [value("f64", -9223372036854776000)],
+);
+
+// ./test/core/conversions.wast:488
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [4669201609102990n]),
+  [value("f64", 4669201609102990)],
+);
+
+// ./test/core/conversions.wast:490
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [9007199254740993n]),
+  [value("f64", 9007199254740992)],
+);
+
+// ./test/core/conversions.wast:491
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [-9007199254740993n]),
+  [value("f64", -9007199254740992)],
+);
+
+// ./test/core/conversions.wast:492
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [9007199254740995n]),
+  [value("f64", 9007199254740996)],
+);
+
+// ./test/core/conversions.wast:493
+assert_return(
+  () => invoke($0, `f64.convert_i64_s`, [-9007199254740995n]),
+  [value("f64", -9007199254740996)],
+);
+
+// ./test/core/conversions.wast:495
+assert_return(() => invoke($0, `f32.convert_i32_u`, [1]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:496
+assert_return(() => invoke($0, `f32.convert_i32_u`, [0]), [value("f32", 0)]);
+
+// ./test/core/conversions.wast:497
+assert_return(() => invoke($0, `f32.convert_i32_u`, [2147483647]), [value("f32", 2147483600)]);
+
+// ./test/core/conversions.wast:498
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-2147483648]), [value("f32", 2147483600)]);
+
+// ./test/core/conversions.wast:499
+assert_return(() => invoke($0, `f32.convert_i32_u`, [305419896]), [value("f32", 305419900)]);
+
+// ./test/core/conversions.wast:500
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-1]), [value("f32", 4294967300)]);
+
+// ./test/core/conversions.wast:501
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-2147483520]), [value("f32", 2147483600)]);
+
+// ./test/core/conversions.wast:502
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-2147483519]), [value("f32", 2147484000)]);
+
+// ./test/core/conversions.wast:503
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-2147483518]), [value("f32", 2147484000)]);
+
+// ./test/core/conversions.wast:504
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-384]), [value("f32", 4294966800)]);
+
+// ./test/core/conversions.wast:505
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-383]), [value("f32", 4294967000)]);
+
+// ./test/core/conversions.wast:506
+assert_return(() => invoke($0, `f32.convert_i32_u`, [-382]), [value("f32", 4294967000)]);
+
+// ./test/core/conversions.wast:508
+assert_return(() => invoke($0, `f32.convert_i32_u`, [16777217]), [value("f32", 16777216)]);
+
+// ./test/core/conversions.wast:509
+assert_return(() => invoke($0, `f32.convert_i32_u`, [16777219]), [value("f32", 16777220)]);
+
+// ./test/core/conversions.wast:511
+assert_return(() => invoke($0, `f32.convert_i64_u`, [1n]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:512
+assert_return(() => invoke($0, `f32.convert_i64_u`, [0n]), [value("f32", 0)]);
+
+// ./test/core/conversions.wast:513
+assert_return(
+  () => invoke($0, `f32.convert_i64_u`, [9223372036854775807n]),
+  [value("f32", 9223372000000000000)],
+);
+
+// ./test/core/conversions.wast:514
+assert_return(
+  () => invoke($0, `f32.convert_i64_u`, [-9223372036854775808n]),
+  [value("f32", 9223372000000000000)],
+);
+
+// ./test/core/conversions.wast:515
+assert_return(() => invoke($0, `f32.convert_i64_u`, [-1n]), [value("f32", 18446744000000000000)]);
+
+// ./test/core/conversions.wast:517
+assert_return(() => invoke($0, `f32.convert_i64_u`, [16777217n]), [value("f32", 16777216)]);
+
+// ./test/core/conversions.wast:518
+assert_return(() => invoke($0, `f32.convert_i64_u`, [16777219n]), [value("f32", 16777220)]);
+
+// ./test/core/conversions.wast:520
+assert_return(
+  () => invoke($0, `f32.convert_i64_u`, [9007199791611905n]),
+  [value("f32", 9007200000000000)],
+);
+
+// ./test/core/conversions.wast:521
+assert_return(
+  () => invoke($0, `f32.convert_i64_u`, [9223371761976868863n]),
+  [value("f32", 9223371500000000000)],
+);
+
+// ./test/core/conversions.wast:522
+assert_return(
+  () => invoke($0, `f32.convert_i64_u`, [-9223371487098961919n]),
+  [value("f32", 9223373000000000000)],
+);
+
+// ./test/core/conversions.wast:523
+assert_return(
+  () => invoke($0, `f32.convert_i64_u`, [-1649267441663n]),
+  [value("f32", 18446743000000000000)],
+);
+
+// ./test/core/conversions.wast:525
+assert_return(() => invoke($0, `f64.convert_i32_u`, [1]), [value("f64", 1)]);
+
+// ./test/core/conversions.wast:526
+assert_return(() => invoke($0, `f64.convert_i32_u`, [0]), [value("f64", 0)]);
+
+// ./test/core/conversions.wast:527
+assert_return(() => invoke($0, `f64.convert_i32_u`, [2147483647]), [value("f64", 2147483647)]);
+
+// ./test/core/conversions.wast:528
+assert_return(() => invoke($0, `f64.convert_i32_u`, [-2147483648]), [value("f64", 2147483648)]);
+
+// ./test/core/conversions.wast:529
+assert_return(() => invoke($0, `f64.convert_i32_u`, [-1]), [value("f64", 4294967295)]);
+
+// ./test/core/conversions.wast:531
+assert_return(() => invoke($0, `f64.convert_i64_u`, [1n]), [value("f64", 1)]);
+
+// ./test/core/conversions.wast:532
+assert_return(() => invoke($0, `f64.convert_i64_u`, [0n]), [value("f64", 0)]);
+
+// ./test/core/conversions.wast:533
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [9223372036854775807n]),
+  [value("f64", 9223372036854776000)],
+);
+
+// ./test/core/conversions.wast:534
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [-9223372036854775808n]),
+  [value("f64", 9223372036854776000)],
+);
+
+// ./test/core/conversions.wast:535
+assert_return(() => invoke($0, `f64.convert_i64_u`, [-1n]), [value("f64", 18446744073709552000)]);
+
+// ./test/core/conversions.wast:536
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [-9223372036854774784n]),
+  [value("f64", 9223372036854776000)],
+);
+
+// ./test/core/conversions.wast:537
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [-9223372036854774783n]),
+  [value("f64", 9223372036854778000)],
+);
+
+// ./test/core/conversions.wast:538
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [-9223372036854774782n]),
+  [value("f64", 9223372036854778000)],
+);
+
+// ./test/core/conversions.wast:539
+assert_return(() => invoke($0, `f64.convert_i64_u`, [-3072n]), [value("f64", 18446744073709548000)]);
+
+// ./test/core/conversions.wast:540
+assert_return(() => invoke($0, `f64.convert_i64_u`, [-3071n]), [value("f64", 18446744073709550000)]);
+
+// ./test/core/conversions.wast:541
+assert_return(() => invoke($0, `f64.convert_i64_u`, [-3070n]), [value("f64", 18446744073709550000)]);
+
+// ./test/core/conversions.wast:543
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [9007199254740993n]),
+  [value("f64", 9007199254740992)],
+);
+
+// ./test/core/conversions.wast:544
+assert_return(
+  () => invoke($0, `f64.convert_i64_u`, [9007199254740995n]),
+  [value("f64", 9007199254740996)],
+);
+
+// ./test/core/conversions.wast:546
+assert_return(() => invoke($0, `f64.promote_f32`, [value("f32", 0)]), [value("f64", 0)]);
+
+// ./test/core/conversions.wast:547
+assert_return(() => invoke($0, `f64.promote_f32`, [value("f32", -0)]), [value("f64", -0)]);
+
+// ./test/core/conversions.wast:548
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f64", 0.000000000000000000000000000000000000000000001401298464324817)],
+);
+
+// ./test/core/conversions.wast:549
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000001401298464324817),
+  ],
+);
+
+// ./test/core/conversions.wast:550
+assert_return(() => invoke($0, `f64.promote_f32`, [value("f32", 1)]), [value("f64", 1)]);
+
+// ./test/core/conversions.wast:551
+assert_return(() => invoke($0, `f64.promote_f32`, [value("f32", -1)]), [value("f64", -1)]);
+
+// ./test/core/conversions.wast:552
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f64", -340282346638528860000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:553
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f64", 340282346638528860000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:555
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [
+    value("f32", 0.0000000000000000000000000000000000015046328),
+  ]),
+  [value("f64", 0.000000000000000000000000000000000001504632769052528)],
+);
+
+// ./test/core/conversions.wast:557
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [
+    value("f32", 66382537000000000000000000000000000000),
+  ]),
+  [value("f64", 66382536710104395000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:558
+assert_return(() => invoke($0, `f64.promote_f32`, [value("f32", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/conversions.wast:559
+assert_return(() => invoke($0, `f64.promote_f32`, [value("f32", -Infinity)]), [value("f64", -Infinity)]);
+
+// ./test/core/conversions.wast:560
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/conversions.wast:561
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/conversions.wast:562
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/conversions.wast:563
+assert_return(
+  () => invoke($0, `f64.promote_f32`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/conversions.wast:565
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 0)]), [value("f32", 0)]);
+
+// ./test/core/conversions.wast:566
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", -0)]), [value("f32", -0)]);
+
+// ./test/core/conversions.wast:567
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/conversions.wast:568
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/conversions.wast:569
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 1)]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:570
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", -1)]), [value("f32", -1)]);
+
+// ./test/core/conversions.wast:571
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000000011754942807573643),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/conversions.wast:572
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.000000000000000000000000000000000000011754942807573643),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/conversions.wast:573
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000000011754942807573642),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/conversions.wast:574
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.000000000000000000000000000000000000011754942807573642),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/conversions.wast:575
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000000000000001401298464324817),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/conversions.wast:576
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.000000000000000000000000000000000000000000001401298464324817),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/conversions.wast:577
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 340282336497324060000000000000000000000),
+  ]),
+  [value("f32", 340282330000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:578
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -340282336497324060000000000000000000000),
+  ]),
+  [value("f32", -340282330000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:579
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 340282336497324100000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:580
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -340282336497324100000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:581
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 340282346638528860000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:582
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -340282346638528860000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:583
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 340282356779733620000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:584
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -340282356779733620000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:585
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 340282356779733660000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/conversions.wast:586
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -340282356779733660000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/conversions.wast:587
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000001504632769052528),
+  ]),
+  [value("f32", 0.0000000000000000000000000000000000015046328)],
+);
+
+// ./test/core/conversions.wast:588
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 66382536710104395000000000000000000000),
+  ]),
+  [value("f32", 66382537000000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:589
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/conversions.wast:590
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", -Infinity)]), [value("f32", -Infinity)]);
+
+// ./test/core/conversions.wast:591
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 1.0000000000000002)]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:592
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 0.9999999999999999)]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:593
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 1.0000000596046448)]), [value("f32", 1)]);
+
+// ./test/core/conversions.wast:594
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 1.000000059604645)]),
+  [value("f32", 1.0000001)],
+);
+
+// ./test/core/conversions.wast:595
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 1.000000178813934)]),
+  [value("f32", 1.0000001)],
+);
+
+// ./test/core/conversions.wast:596
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 1.0000001788139343)]),
+  [value("f32", 1.0000002)],
+);
+
+// ./test/core/conversions.wast:597
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 1.0000002980232239)]),
+  [value("f32", 1.0000002)],
+);
+
+// ./test/core/conversions.wast:598
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 16777217)]), [value("f32", 16777216)]);
+
+// ./test/core/conversions.wast:599
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 16777217.000000004)]),
+  [value("f32", 16777218)],
+);
+
+// ./test/core/conversions.wast:600
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 16777218.999999996)]),
+  [value("f32", 16777218)],
+);
+
+// ./test/core/conversions.wast:601
+assert_return(() => invoke($0, `f32.demote_f64`, [value("f64", 16777219)]), [value("f32", 16777220)]);
+
+// ./test/core/conversions.wast:602
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", 424258443299142700000000000000000)]),
+  [value("f32", 424258450000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:603
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.0000000000000000000000000000000001569262107843488),
+  ]),
+  [value("f32", 0.00000000000000000000000000000000015692621)],
+);
+
+// ./test/core/conversions.wast:604
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000000010551773688605172),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000010551773)],
+);
+
+// ./test/core/conversions.wast:605
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [value("f64", -2.8238128484141933)]),
+  [value("f32", -2.823813)],
+);
+
+// ./test/core/conversions.wast:606
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -9063376370095757000000000000000000),
+  ]),
+  [value("f32", -9063376000000000000000000000000000)],
+);
+
+// ./test/core/conversions.wast:607
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/conversions.wast:608
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/conversions.wast:609
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/conversions.wast:610
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/conversions.wast:611
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/conversions.wast:612
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/conversions.wast:613
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.0000000000000000000000000000000000000000000007006492321624085),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/conversions.wast:614
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.0000000000000000000000000000000000000000000007006492321624085),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/conversions.wast:615
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", 0.0000000000000000000000000000000000000000000007006492321624087),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/conversions.wast:616
+assert_return(
+  () => invoke($0, `f32.demote_f64`, [
+    value("f64", -0.0000000000000000000000000000000000000000000007006492321624087),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/conversions.wast:618
+assert_return(() => invoke($0, `f32.reinterpret_i32`, [0]), [value("f32", 0)]);
+
+// ./test/core/conversions.wast:619
+assert_return(() => invoke($0, `f32.reinterpret_i32`, [-2147483648]), [value("f32", -0)]);
+
+// ./test/core/conversions.wast:620
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [1]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/conversions.wast:621
+assert_return(() => invoke($0, `f32.reinterpret_i32`, [-1]), [bytes("f32", [0xff, 0xff, 0xff, 0xff])]);
+
+// ./test/core/conversions.wast:622
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [123456789]),
+  [value("f32", 0.00000000000000000000000000000000016535997)],
+);
+
+// ./test/core/conversions.wast:623
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [-2147483647]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/conversions.wast:624
+assert_return(() => invoke($0, `f32.reinterpret_i32`, [2139095040]), [value("f32", Infinity)]);
+
+// ./test/core/conversions.wast:625
+assert_return(() => invoke($0, `f32.reinterpret_i32`, [-8388608]), [value("f32", -Infinity)]);
+
+// ./test/core/conversions.wast:626
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [2143289344]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/conversions.wast:627
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [-4194304]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/conversions.wast:628
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [2141192192]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])],
+);
+
+// ./test/core/conversions.wast:629
+assert_return(
+  () => invoke($0, `f32.reinterpret_i32`, [-6291456]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0xff])],
+);
+
+// ./test/core/conversions.wast:631
+assert_return(() => invoke($0, `f64.reinterpret_i64`, [0n]), [value("f64", 0)]);
+
+// ./test/core/conversions.wast:632
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [1n]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/conversions.wast:633
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [-1n]),
+  [bytes("f64", [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/conversions.wast:634
+assert_return(() => invoke($0, `f64.reinterpret_i64`, [-9223372036854775808n]), [value("f64", -0)]);
+
+// ./test/core/conversions.wast:635
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [1234567890n]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000609957582),
+  ],
+);
+
+// ./test/core/conversions.wast:636
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [-9223372036854775807n]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/conversions.wast:637
+assert_return(() => invoke($0, `f64.reinterpret_i64`, [9218868437227405312n]), [value("f64", Infinity)]);
+
+// ./test/core/conversions.wast:638
+assert_return(() => invoke($0, `f64.reinterpret_i64`, [-4503599627370496n]), [value("f64", -Infinity)]);
+
+// ./test/core/conversions.wast:639
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [9221120237041090560n]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/conversions.wast:640
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [-2251799813685248n]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/conversions.wast:641
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [9219994337134247936n]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/conversions.wast:642
+assert_return(
+  () => invoke($0, `f64.reinterpret_i64`, [-3377699720527872n]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])],
+);
+
+// ./test/core/conversions.wast:644
+assert_return(() => invoke($0, `i32.reinterpret_f32`, [value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/conversions.wast:645
+assert_return(() => invoke($0, `i32.reinterpret_f32`, [value("f32", -0)]), [value("i32", -2147483648)]);
+
+// ./test/core/conversions.wast:646
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/conversions.wast:647
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [bytes("f32", [0xff, 0xff, 0xff, 0xff])]),
+  [value("i32", -1)],
+);
+
+// ./test/core/conversions.wast:648
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", -2147483647)],
+);
+
+// ./test/core/conversions.wast:649
+assert_return(() => invoke($0, `i32.reinterpret_f32`, [value("f32", 1)]), [value("i32", 1065353216)]);
+
+// ./test/core/conversions.wast:650
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [value("f32", 3.1415925)]),
+  [value("i32", 1078530010)],
+);
+
+// ./test/core/conversions.wast:651
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 2139095039)],
+);
+
+// ./test/core/conversions.wast:652
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", -8388609)],
+);
+
+// ./test/core/conversions.wast:653
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [value("f32", Infinity)]),
+  [value("i32", 2139095040)],
+);
+
+// ./test/core/conversions.wast:654
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [value("f32", -Infinity)]),
+  [value("i32", -8388608)],
+);
+
+// ./test/core/conversions.wast:655
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 2143289344)],
+);
+
+// ./test/core/conversions.wast:656
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", -4194304)],
+);
+
+// ./test/core/conversions.wast:657
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 2141192192)],
+);
+
+// ./test/core/conversions.wast:658
+assert_return(
+  () => invoke($0, `i32.reinterpret_f32`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", -6291456)],
+);
+
+// ./test/core/conversions.wast:660
+assert_return(() => invoke($0, `i64.reinterpret_f64`, [value("f64", 0)]), [value("i64", 0n)]);
+
+// ./test/core/conversions.wast:661
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [value("f64", -0)]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/conversions.wast:662
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", 1n)],
+);
+
+// ./test/core/conversions.wast:663
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    bytes("f64", [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/conversions.wast:664
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i64", -9223372036854775807n)],
+);
+
+// ./test/core/conversions.wast:665
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [value("f64", 1)]),
+  [value("i64", 4607182418800017408n)],
+);
+
+// ./test/core/conversions.wast:666
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [value("f64", 3.14159265358979)]),
+  [value("i64", 4614256656552045841n)],
+);
+
+// ./test/core/conversions.wast:667
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i64", 9218868437227405311n)],
+);
+
+// ./test/core/conversions.wast:668
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i64", -4503599627370497n)],
+);
+
+// ./test/core/conversions.wast:669
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [value("f64", Infinity)]),
+  [value("i64", 9218868437227405312n)],
+);
+
+// ./test/core/conversions.wast:670
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [value("f64", -Infinity)]),
+  [value("i64", -4503599627370496n)],
+);
+
+// ./test/core/conversions.wast:671
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/conversions.wast:672
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i64", -2251799813685248n)],
+);
+
+// ./test/core/conversions.wast:673
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i64", 9219994337134247936n)],
+);
+
+// ./test/core/conversions.wast:674
+assert_return(
+  () => invoke($0, `i64.reinterpret_f64`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i64", -3377699720527872n)],
+);
+
+// ./test/core/conversions.wast:678
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.wrap_i64 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:679
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.trunc_f32_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:680
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.trunc_f32_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:681
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.trunc_f64_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:682
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.trunc_f64_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:683
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.reinterpret_f32 (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:684
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.extend_i32_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:685
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.extend_i32_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:686
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.trunc_f32_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:687
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.trunc_f32_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:688
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.trunc_f64_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:689
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.trunc_f64_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:690
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.reinterpret_f64 (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:691
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.convert_i32_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:692
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.convert_i32_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:693
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.convert_i64_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:694
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.convert_i64_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:695
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.demote_f64 (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:696
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.reinterpret_i32 (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:697
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.convert_i32_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:698
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.convert_i32_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:699
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.convert_i64_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:700
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.convert_i64_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:701
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.promote_f32 (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/conversions.wast:702
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.reinterpret_i64 (i32.const 0))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/custom.wast.js b/js/src/jit-test/tests/wasm/spec/spec/custom.wast.js
new file mode 100644
index 0000000000..c2883feba5
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/custom.wast.js
@@ -0,0 +1,157 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/custom.wast
+
+// ./test/core/custom.wast:1
+let $0 = instantiate(`(module binary
+  "\\00asm" "\\01\\00\\00\\00"
+  "\\00\\24\\10" "a custom section" "this is the payload"
+  "\\00\\20\\10" "a custom section" "this is payload"
+  "\\00\\11\\10" "a custom section" ""
+  "\\00\\10\\00" "" "this is payload"
+  "\\00\\01\\00" "" ""
+  "\\00\\24\\10" "\\00\\00custom sectio\\00" "this is the payload"
+  "\\00\\24\\10" "\\ef\\bb\\bfa custom sect" "this is the payload"
+  "\\00\\24\\10" "a custom sect\\e2\\8c\\a3" "this is the payload"
+  "\\00\\1f\\16" "module within a module" "\\00asm" "\\01\\00\\00\\00"
+)`);
+
+// ./test/core/custom.wast:14
+let $1 = instantiate(`(module binary
+  "\\00asm" "\\01\\00\\00\\00"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\01\\01\\00"  ;; type section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\02\\01\\00"  ;; import section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\03\\01\\00"  ;; function section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\04\\01\\00"  ;; table section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\05\\01\\00"  ;; memory section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\06\\01\\00"  ;; global section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\07\\01\\00"  ;; export section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\09\\01\\00"  ;; element section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\0a\\01\\00"  ;; code section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+  "\\0b\\01\\00"  ;; data section
+  "\\00\\0e\\06" "custom" "payload"
+  "\\00\\0e\\06" "custom" "payload"
+)`);
+
+// ./test/core/custom.wast:50
+let $2 = instantiate(`(module binary
+  "\\00asm" "\\01\\00\\00\\00"
+  "\\01\\07\\01\\60\\02\\7f\\7f\\01\\7f"                ;; type section
+  "\\00\\1a\\06" "custom" "this is the payload"   ;; custom section
+  "\\03\\02\\01\\00"                               ;; function section
+  "\\07\\0a\\01\\06\\61\\64\\64\\54\\77\\6f\\00\\00"       ;; export section
+  "\\0a\\09\\01\\07\\00\\20\\00\\20\\01\\6a\\0b"          ;; code section
+  "\\00\\1b\\07" "custom2" "this is the payload"  ;; custom section
+)`);
+
+// ./test/core/custom.wast:60
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:68
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\00"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:76
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\00\\00\\05\\01\\00\\07\\00\\00"
+  )`),
+  `unexpected end`,
+);
+
+// ./test/core/custom.wast:84
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\26\\10" "a custom section" "this is the payload"
+  )`),
+  `length out of bounds`,
+);
+
+// ./test/core/custom.wast:92
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\00\\25\\10" "a custom section" "this is the payload"
+    "\\00\\24\\10" "a custom section" "this is the payload"
+  )`),
+  `malformed section id`,
+);
+
+// ./test/core/custom.wast:101
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\01\\07\\01\\60\\02\\7f\\7f\\01\\7f"                         ;; type section
+    "\\00\\25\\10" "a custom section" "this is the payload"  ;; wrong length!
+    "\\03\\02\\01\\00"                                        ;; function section
+    "\\0a\\09\\01\\07\\00\\20\\00\\20\\01\\6a\\0b"                   ;; code section
+    "\\00\\1b\\07" "custom2" "this is the payload"           ;; custom section
+  )`),
+  `function and code section have inconsistent lengths`,
+);
+
+// ./test/core/custom.wast:114
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm\\01\\00\\00\\00"
+    "\\00asm\\01\\00\\00\\00"
+  )`),
+  `length out of bounds`,
+);
+
+// ./test/core/custom.wast:122
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\05\\03\\01\\00\\01"                         ;; memory section
+    "\\0c\\01\\02"                               ;; data count section (2 segments)
+    "\\0b\\06\\01\\00\\41\\00\\0b\\00"                ;; data section (1 segment)
+  )`),
+  `data count and data section have inconsistent lengths`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/directives.txt b/js/src/jit-test/tests/wasm/spec/spec/directives.txt
new file mode 100644
index 0000000000..59cbb55d2b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/directives.txt
@@ -0,0 +1 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--wasm-test-serialization; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported(); local-include:harness/harness.js; test-also=--no-avx; skip-variant-if: --no-avx, !getBuildConfiguration().x86 && !getBuildConfiguration().x64 || getBuildConfiguration().simulator
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/spec/endianness.wast.js b/js/src/jit-test/tests/wasm/spec/spec/endianness.wast.js
new file mode 100644
index 0000000000..e408d9e677
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/endianness.wast.js
@@ -0,0 +1,385 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/endianness.wast
+
+// ./test/core/endianness.wast:1
+let $0 = instantiate(`(module
+  (memory 1)
+
+  ;; Stores an i16 value in little-endian-format
+  (func $$i16_store_little (param $$address i32) (param $$value i32)
+    (i32.store8 (local.get $$address) (local.get $$value))
+    (i32.store8 (i32.add (local.get $$address) (i32.const 1)) (i32.shr_u (local.get $$value) (i32.const 8)))
+  )
+
+  ;; Stores an i32 value in little-endian format
+  (func $$i32_store_little (param $$address i32) (param $$value i32)
+    (call $$i16_store_little (local.get $$address) (local.get $$value))
+    (call $$i16_store_little (i32.add (local.get $$address) (i32.const 2)) (i32.shr_u (local.get $$value) (i32.const 16)))
+  )
+
+  ;; Stores an i64 value in little-endian format
+  (func $$i64_store_little (param $$address i32) (param $$value i64)
+    (call $$i32_store_little (local.get $$address) (i32.wrap_i64 (local.get $$value)))
+    (call $$i32_store_little (i32.add (local.get $$address) (i32.const 4)) (i32.wrap_i64 (i64.shr_u (local.get $$value) (i64.const 32))))
+  )
+
+  ;; Loads an i16 value in little-endian format
+  (func $$i16_load_little (param $$address i32) (result i32)
+    (i32.or
+      (i32.load8_u (local.get $$address))
+      (i32.shl (i32.load8_u (i32.add (local.get $$address) (i32.const 1))) (i32.const 8))
+    )
+  )
+
+  ;; Loads an i32 value in little-endian format
+  (func $$i32_load_little (param $$address i32) (result i32)
+    (i32.or
+      (call $$i16_load_little (local.get $$address))
+      (i32.shl (call $$i16_load_little (i32.add (local.get $$address) (i32.const 2))) (i32.const 16))
+    )
+  )
+
+  ;; Loads an i64 value in little-endian format
+  (func $$i64_load_little (param $$address i32) (result i64)
+    (i64.or
+      (i64.extend_i32_u (call $$i32_load_little (local.get $$address)))
+      (i64.shl (i64.extend_i32_u (call $$i32_load_little (i32.add (local.get $$address) (i32.const 4)))) (i64.const 32))
+    )
+  )
+
+  (func (export "i32_load16_s") (param $$value i32) (result i32)
+    (call $$i16_store_little (i32.const 0) (local.get $$value))
+    (i32.load16_s (i32.const 0))
+  )
+
+  (func (export "i32_load16_u") (param $$value i32) (result i32)
+    (call $$i16_store_little (i32.const 0) (local.get $$value))
+    (i32.load16_u (i32.const 0))
+  )
+
+  (func (export "i32_load") (param $$value i32) (result i32)
+    (call $$i32_store_little (i32.const 0) (local.get $$value))
+    (i32.load (i32.const 0))
+  )
+
+  (func (export "i64_load16_s") (param $$value i64) (result i64)
+    (call $$i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load16_s (i32.const 0))
+  )
+
+  (func (export "i64_load16_u") (param $$value i64) (result i64)
+    (call $$i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load16_u (i32.const 0))
+  )
+
+  (func (export "i64_load32_s") (param $$value i64) (result i64)
+    (call $$i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load32_s (i32.const 0))
+  )
+
+  (func (export "i64_load32_u") (param $$value i64) (result i64)
+    (call $$i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $$value)))
+    (i64.load32_u (i32.const 0))
+  )
+
+  (func (export "i64_load") (param $$value i64) (result i64)
+    (call $$i64_store_little (i32.const 0) (local.get $$value))
+    (i64.load (i32.const 0))
+  )
+
+  (func (export "f32_load") (param $$value f32) (result f32)
+    (call $$i32_store_little (i32.const 0) (i32.reinterpret_f32 (local.get $$value)))
+    (f32.load (i32.const 0))
+  )
+
+  (func (export "f64_load") (param $$value f64) (result f64)
+    (call $$i64_store_little (i32.const 0) (i64.reinterpret_f64 (local.get $$value)))
+    (f64.load (i32.const 0))
+  )
+
+
+  (func (export "i32_store16") (param $$value i32) (result i32)
+    (i32.store16 (i32.const 0) (local.get $$value))
+    (call $$i16_load_little (i32.const 0))
+  )
+
+  (func (export "i32_store") (param $$value i32) (result i32)
+    (i32.store (i32.const 0) (local.get $$value))
+    (call $$i32_load_little (i32.const 0))
+  )
+
+  (func (export "i64_store16") (param $$value i64) (result i64)
+    (i64.store16 (i32.const 0) (local.get $$value))
+    (i64.extend_i32_u (call $$i16_load_little (i32.const 0)))
+  )
+
+  (func (export "i64_store32") (param $$value i64) (result i64)
+    (i64.store32 (i32.const 0) (local.get $$value))
+    (i64.extend_i32_u (call $$i32_load_little (i32.const 0)))
+  )
+
+  (func (export "i64_store") (param $$value i64) (result i64)
+    (i64.store (i32.const 0) (local.get $$value))
+    (call $$i64_load_little (i32.const 0))
+  )
+
+  (func (export "f32_store") (param $$value f32) (result f32)
+    (f32.store (i32.const 0) (local.get $$value))
+    (f32.reinterpret_i32 (call $$i32_load_little (i32.const 0)))
+  )
+
+  (func (export "f64_store") (param $$value f64) (result f64)
+    (f64.store (i32.const 0) (local.get $$value))
+    (f64.reinterpret_i64 (call $$i64_load_little (i32.const 0)))
+  )
+)`);
+
+// ./test/core/endianness.wast:133
+assert_return(() => invoke($0, `i32_load16_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/endianness.wast:134
+assert_return(() => invoke($0, `i32_load16_s`, [-4242]), [value("i32", -4242)]);
+
+// ./test/core/endianness.wast:135
+assert_return(() => invoke($0, `i32_load16_s`, [42]), [value("i32", 42)]);
+
+// ./test/core/endianness.wast:136
+assert_return(() => invoke($0, `i32_load16_s`, [12816]), [value("i32", 12816)]);
+
+// ./test/core/endianness.wast:138
+assert_return(() => invoke($0, `i32_load16_u`, [-1]), [value("i32", 65535)]);
+
+// ./test/core/endianness.wast:139
+assert_return(() => invoke($0, `i32_load16_u`, [-4242]), [value("i32", 61294)]);
+
+// ./test/core/endianness.wast:140
+assert_return(() => invoke($0, `i32_load16_u`, [42]), [value("i32", 42)]);
+
+// ./test/core/endianness.wast:141
+assert_return(() => invoke($0, `i32_load16_u`, [51966]), [value("i32", 51966)]);
+
+// ./test/core/endianness.wast:143
+assert_return(() => invoke($0, `i32_load`, [-1]), [value("i32", -1)]);
+
+// ./test/core/endianness.wast:144
+assert_return(() => invoke($0, `i32_load`, [-42424242]), [value("i32", -42424242)]);
+
+// ./test/core/endianness.wast:145
+assert_return(() => invoke($0, `i32_load`, [42424242]), [value("i32", 42424242)]);
+
+// ./test/core/endianness.wast:146
+assert_return(() => invoke($0, `i32_load`, [-1414717974]), [value("i32", -1414717974)]);
+
+// ./test/core/endianness.wast:148
+assert_return(() => invoke($0, `i64_load16_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness.wast:149
+assert_return(() => invoke($0, `i64_load16_s`, [-4242n]), [value("i64", -4242n)]);
+
+// ./test/core/endianness.wast:150
+assert_return(() => invoke($0, `i64_load16_s`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/endianness.wast:151
+assert_return(() => invoke($0, `i64_load16_s`, [12816n]), [value("i64", 12816n)]);
+
+// ./test/core/endianness.wast:153
+assert_return(() => invoke($0, `i64_load16_u`, [-1n]), [value("i64", 65535n)]);
+
+// ./test/core/endianness.wast:154
+assert_return(() => invoke($0, `i64_load16_u`, [-4242n]), [value("i64", 61294n)]);
+
+// ./test/core/endianness.wast:155
+assert_return(() => invoke($0, `i64_load16_u`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/endianness.wast:156
+assert_return(() => invoke($0, `i64_load16_u`, [51966n]), [value("i64", 51966n)]);
+
+// ./test/core/endianness.wast:158
+assert_return(() => invoke($0, `i64_load32_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness.wast:159
+assert_return(() => invoke($0, `i64_load32_s`, [-42424242n]), [value("i64", -42424242n)]);
+
+// ./test/core/endianness.wast:160
+assert_return(() => invoke($0, `i64_load32_s`, [42424242n]), [value("i64", 42424242n)]);
+
+// ./test/core/endianness.wast:161
+assert_return(() => invoke($0, `i64_load32_s`, [305419896n]), [value("i64", 305419896n)]);
+
+// ./test/core/endianness.wast:163
+assert_return(() => invoke($0, `i64_load32_u`, [-1n]), [value("i64", 4294967295n)]);
+
+// ./test/core/endianness.wast:164
+assert_return(() => invoke($0, `i64_load32_u`, [-42424242n]), [value("i64", 4252543054n)]);
+
+// ./test/core/endianness.wast:165
+assert_return(() => invoke($0, `i64_load32_u`, [42424242n]), [value("i64", 42424242n)]);
+
+// ./test/core/endianness.wast:166
+assert_return(() => invoke($0, `i64_load32_u`, [2880249322n]), [value("i64", 2880249322n)]);
+
+// ./test/core/endianness.wast:168
+assert_return(() => invoke($0, `i64_load`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness.wast:169
+assert_return(() => invoke($0, `i64_load`, [-42424242n]), [value("i64", -42424242n)]);
+
+// ./test/core/endianness.wast:170
+assert_return(() => invoke($0, `i64_load`, [2880249322n]), [value("i64", 2880249322n)]);
+
+// ./test/core/endianness.wast:171
+assert_return(
+  () => invoke($0, `i64_load`, [-6075977126246539798n]),
+  [value("i64", -6075977126246539798n)],
+);
+
+// ./test/core/endianness.wast:173
+assert_return(() => invoke($0, `f32_load`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/endianness.wast:174
+assert_return(() => invoke($0, `f32_load`, [value("f32", 0.01234)]), [value("f32", 0.01234)]);
+
+// ./test/core/endianness.wast:175
+assert_return(() => invoke($0, `f32_load`, [value("f32", 4242.4243)]), [value("f32", 4242.4243)]);
+
+// ./test/core/endianness.wast:176
+assert_return(
+  () => invoke($0, `f32_load`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/endianness.wast:178
+assert_return(() => invoke($0, `f64_load`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/endianness.wast:179
+assert_return(() => invoke($0, `f64_load`, [value("f64", 1234.56789)]), [value("f64", 1234.56789)]);
+
+// ./test/core/endianness.wast:180
+assert_return(
+  () => invoke($0, `f64_load`, [value("f64", 424242.424242)]),
+  [value("f64", 424242.424242)],
+);
+
+// ./test/core/endianness.wast:181
+assert_return(
+  () => invoke($0, `f64_load`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/endianness.wast:184
+assert_return(() => invoke($0, `i32_store16`, [-1]), [value("i32", 65535)]);
+
+// ./test/core/endianness.wast:185
+assert_return(() => invoke($0, `i32_store16`, [-4242]), [value("i32", 61294)]);
+
+// ./test/core/endianness.wast:186
+assert_return(() => invoke($0, `i32_store16`, [42]), [value("i32", 42)]);
+
+// ./test/core/endianness.wast:187
+assert_return(() => invoke($0, `i32_store16`, [51966]), [value("i32", 51966)]);
+
+// ./test/core/endianness.wast:189
+assert_return(() => invoke($0, `i32_store`, [-1]), [value("i32", -1)]);
+
+// ./test/core/endianness.wast:190
+assert_return(() => invoke($0, `i32_store`, [-4242]), [value("i32", -4242)]);
+
+// ./test/core/endianness.wast:191
+assert_return(() => invoke($0, `i32_store`, [42424242]), [value("i32", 42424242)]);
+
+// ./test/core/endianness.wast:192
+assert_return(() => invoke($0, `i32_store`, [-559035650]), [value("i32", -559035650)]);
+
+// ./test/core/endianness.wast:194
+assert_return(() => invoke($0, `i64_store16`, [-1n]), [value("i64", 65535n)]);
+
+// ./test/core/endianness.wast:195
+assert_return(() => invoke($0, `i64_store16`, [-4242n]), [value("i64", 61294n)]);
+
+// ./test/core/endianness.wast:196
+assert_return(() => invoke($0, `i64_store16`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/endianness.wast:197
+assert_return(() => invoke($0, `i64_store16`, [51966n]), [value("i64", 51966n)]);
+
+// ./test/core/endianness.wast:199
+assert_return(() => invoke($0, `i64_store32`, [-1n]), [value("i64", 4294967295n)]);
+
+// ./test/core/endianness.wast:200
+assert_return(() => invoke($0, `i64_store32`, [-4242n]), [value("i64", 4294963054n)]);
+
+// ./test/core/endianness.wast:201
+assert_return(() => invoke($0, `i64_store32`, [42424242n]), [value("i64", 42424242n)]);
+
+// ./test/core/endianness.wast:202
+assert_return(() => invoke($0, `i64_store32`, [3735931646n]), [value("i64", 3735931646n)]);
+
+// ./test/core/endianness.wast:204
+assert_return(() => invoke($0, `i64_store`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/endianness.wast:205
+assert_return(() => invoke($0, `i64_store`, [-42424242n]), [value("i64", -42424242n)]);
+
+// ./test/core/endianness.wast:206
+assert_return(() => invoke($0, `i64_store`, [2880249322n]), [value("i64", 2880249322n)]);
+
+// ./test/core/endianness.wast:207
+assert_return(
+  () => invoke($0, `i64_store`, [-6075977126246539798n]),
+  [value("i64", -6075977126246539798n)],
+);
+
+// ./test/core/endianness.wast:209
+assert_return(() => invoke($0, `f32_store`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/endianness.wast:210
+assert_return(() => invoke($0, `f32_store`, [value("f32", 0.01234)]), [value("f32", 0.01234)]);
+
+// ./test/core/endianness.wast:211
+assert_return(() => invoke($0, `f32_store`, [value("f32", 4242.4243)]), [value("f32", 4242.4243)]);
+
+// ./test/core/endianness.wast:212
+assert_return(
+  () => invoke($0, `f32_store`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/endianness.wast:214
+assert_return(() => invoke($0, `f64_store`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/endianness.wast:215
+assert_return(() => invoke($0, `f64_store`, [value("f64", 1234.56789)]), [value("f64", 1234.56789)]);
+
+// ./test/core/endianness.wast:216
+assert_return(
+  () => invoke($0, `f64_store`, [value("f64", 424242.424242)]),
+  [value("f64", 424242.424242)],
+);
+
+// ./test/core/endianness.wast:217
+assert_return(
+  () => invoke($0, `f64_store`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/f32.wast.js b/js/src/jit-test/tests/wasm/spec/spec/f32.wast.js
new file mode 100644
index 0000000000..c80cfd6421
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/f32.wast.js
@@ -0,0 +1,18629 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/f32.wast
+
+// ./test/core/f32.wast:5
+let $0 = instantiate(`(module
+  (func (export "add") (param $$x f32) (param $$y f32) (result f32) (f32.add (local.get $$x) (local.get $$y)))
+  (func (export "sub") (param $$x f32) (param $$y f32) (result f32) (f32.sub (local.get $$x) (local.get $$y)))
+  (func (export "mul") (param $$x f32) (param $$y f32) (result f32) (f32.mul (local.get $$x) (local.get $$y)))
+  (func (export "div") (param $$x f32) (param $$y f32) (result f32) (f32.div (local.get $$x) (local.get $$y)))
+  (func (export "sqrt") (param $$x f32) (result f32) (f32.sqrt (local.get $$x)))
+  (func (export "min") (param $$x f32) (param $$y f32) (result f32) (f32.min (local.get $$x) (local.get $$y)))
+  (func (export "max") (param $$x f32) (param $$y f32) (result f32) (f32.max (local.get $$x) (local.get $$y)))
+  (func (export "ceil") (param $$x f32) (result f32) (f32.ceil (local.get $$x)))
+  (func (export "floor") (param $$x f32) (result f32) (f32.floor (local.get $$x)))
+  (func (export "trunc") (param $$x f32) (result f32) (f32.trunc (local.get $$x)))
+  (func (export "nearest") (param $$x f32) (result f32) (f32.nearest (local.get $$x)))
+)`);
+
+// ./test/core/f32.wast:19
+assert_return(() => invoke($0, `add`, [value("f32", -0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:20
+assert_return(() => invoke($0, `add`, [value("f32", -0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:21
+assert_return(() => invoke($0, `add`, [value("f32", 0), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:22
+assert_return(() => invoke($0, `add`, [value("f32", 0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:23
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:24
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:25
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:26
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:27
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:28
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:29
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:30
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:31
+assert_return(() => invoke($0, `add`, [value("f32", -0), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:32
+assert_return(() => invoke($0, `add`, [value("f32", -0), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:33
+assert_return(() => invoke($0, `add`, [value("f32", 0), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:34
+assert_return(() => invoke($0, `add`, [value("f32", 0), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:35
+assert_return(() => invoke($0, `add`, [value("f32", -0), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:36
+assert_return(() => invoke($0, `add`, [value("f32", -0), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:37
+assert_return(() => invoke($0, `add`, [value("f32", 0), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:38
+assert_return(() => invoke($0, `add`, [value("f32", 0), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:39
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:40
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:41
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:42
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:43
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:44
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:45
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:46
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:47
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:48
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:49
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:50
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:51
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:52
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:53
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:54
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:55
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:56
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:57
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:58
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:59
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:60
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:61
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:62
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:63
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:64
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:65
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:66
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:67
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:68
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:69
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:70
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:71
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:72
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:73
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:74
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:75
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:76
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:77
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:78
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:79
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:80
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:81
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:82
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:83
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:84
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:85
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:86
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:87
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:88
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:89
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:90
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:91
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:92
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:93
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:94
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:95
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:96
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:97
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:98
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:99
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:100
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:101
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:102
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:103
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:104
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:105
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:106
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:107
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:108
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:109
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:110
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:111
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:112
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:113
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:114
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:115
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:116
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:117
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:118
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:119
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:120
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:121
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:122
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:123
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:124
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:125
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:126
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:127
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:128
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:129
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:130
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:131
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:132
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:133
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:134
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:135
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:136
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:137
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:138
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:139
+assert_return(() => invoke($0, `add`, [value("f32", -0.5), value("f32", -0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:140
+assert_return(() => invoke($0, `add`, [value("f32", -0.5), value("f32", 0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:141
+assert_return(() => invoke($0, `add`, [value("f32", 0.5), value("f32", -0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:142
+assert_return(() => invoke($0, `add`, [value("f32", 0.5), value("f32", 0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:143
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:144
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:145
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:146
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:147
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:148
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:149
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:150
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:151
+assert_return(() => invoke($0, `add`, [value("f32", -0.5), value("f32", -0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:152
+assert_return(() => invoke($0, `add`, [value("f32", -0.5), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:153
+assert_return(() => invoke($0, `add`, [value("f32", 0.5), value("f32", -0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:154
+assert_return(() => invoke($0, `add`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:155
+assert_return(() => invoke($0, `add`, [value("f32", -0.5), value("f32", -1)]), [value("f32", -1.5)]);
+
+// ./test/core/f32.wast:156
+assert_return(() => invoke($0, `add`, [value("f32", -0.5), value("f32", 1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:157
+assert_return(() => invoke($0, `add`, [value("f32", 0.5), value("f32", -1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:158
+assert_return(() => invoke($0, `add`, [value("f32", 0.5), value("f32", 1)]), [value("f32", 1.5)]);
+
+// ./test/core/f32.wast:159
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", -6.7831855)],
+);
+
+// ./test/core/f32.wast:160
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", 5.7831855)],
+);
+
+// ./test/core/f32.wast:161
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", -5.7831855)],
+);
+
+// ./test/core/f32.wast:162
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", 6.7831855)],
+);
+
+// ./test/core/f32.wast:163
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:164
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:165
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:166
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:167
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:168
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:169
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:170
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:171
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:172
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:173
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:174
+assert_return(
+  () => invoke($0, `add`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:175
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:176
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:177
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:178
+assert_return(
+  () => invoke($0, `add`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:179
+assert_return(() => invoke($0, `add`, [value("f32", -1), value("f32", -0)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:180
+assert_return(() => invoke($0, `add`, [value("f32", -1), value("f32", 0)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:181
+assert_return(() => invoke($0, `add`, [value("f32", 1), value("f32", -0)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:182
+assert_return(() => invoke($0, `add`, [value("f32", 1), value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:183
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:184
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:185
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:186
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:187
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:188
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:189
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:190
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:191
+assert_return(() => invoke($0, `add`, [value("f32", -1), value("f32", -0.5)]), [value("f32", -1.5)]);
+
+// ./test/core/f32.wast:192
+assert_return(() => invoke($0, `add`, [value("f32", -1), value("f32", 0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:193
+assert_return(() => invoke($0, `add`, [value("f32", 1), value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:194
+assert_return(() => invoke($0, `add`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 1.5)]);
+
+// ./test/core/f32.wast:195
+assert_return(() => invoke($0, `add`, [value("f32", -1), value("f32", -1)]), [value("f32", -2)]);
+
+// ./test/core/f32.wast:196
+assert_return(() => invoke($0, `add`, [value("f32", -1), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:197
+assert_return(() => invoke($0, `add`, [value("f32", 1), value("f32", -1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:198
+assert_return(() => invoke($0, `add`, [value("f32", 1), value("f32", 1)]), [value("f32", 2)]);
+
+// ./test/core/f32.wast:199
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), value("f32", -6.2831855)]),
+  [value("f32", -7.2831855)],
+);
+
+// ./test/core/f32.wast:200
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), value("f32", 6.2831855)]),
+  [value("f32", 5.2831855)],
+);
+
+// ./test/core/f32.wast:201
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), value("f32", -6.2831855)]),
+  [value("f32", -5.2831855)],
+);
+
+// ./test/core/f32.wast:202
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), value("f32", 6.2831855)]),
+  [value("f32", 7.2831855)],
+);
+
+// ./test/core/f32.wast:203
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:204
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:205
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:206
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:207
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:208
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:209
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:210
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:211
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:212
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:213
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:214
+assert_return(
+  () => invoke($0, `add`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:215
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:216
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:217
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:218
+assert_return(
+  () => invoke($0, `add`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:219
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", -0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:220
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", 0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:221
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", -0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:222
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", 0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:223
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:224
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:225
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:226
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:227
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:228
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:229
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:230
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:231
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", -6.7831855)],
+);
+
+// ./test/core/f32.wast:232
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", -5.7831855)],
+);
+
+// ./test/core/f32.wast:233
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", 5.7831855)],
+);
+
+// ./test/core/f32.wast:234
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 6.7831855)],
+);
+
+// ./test/core/f32.wast:235
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", -1)]),
+  [value("f32", -7.2831855)],
+);
+
+// ./test/core/f32.wast:236
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", 1)]),
+  [value("f32", -5.2831855)],
+);
+
+// ./test/core/f32.wast:237
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", -1)]),
+  [value("f32", 5.2831855)],
+);
+
+// ./test/core/f32.wast:238
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", 1)]),
+  [value("f32", 7.2831855)],
+);
+
+// ./test/core/f32.wast:239
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -12.566371)],
+);
+
+// ./test/core/f32.wast:240
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:241
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:242
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 12.566371)],
+);
+
+// ./test/core/f32.wast:243
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:244
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:245
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:246
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:247
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:248
+assert_return(
+  () => invoke($0, `add`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:249
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:250
+assert_return(
+  () => invoke($0, `add`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:251
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:252
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:253
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:254
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:255
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:256
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:257
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:258
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:259
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:260
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:261
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:262
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:263
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:264
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:265
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:266
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:267
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:268
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:269
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:270
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:271
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:272
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:273
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:274
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:275
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:276
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:277
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:278
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:279
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:280
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:281
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:282
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:283
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:284
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:285
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:286
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:287
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:288
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:289
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:290
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:291
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:292
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:293
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:294
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:295
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:296
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:297
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:298
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:299
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:300
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", 0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:301
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", -0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:302
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:303
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:304
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:305
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:306
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:307
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:308
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:309
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:310
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:311
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:312
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:313
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:314
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:315
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:316
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", 1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:317
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", -1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:318
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:319
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:320
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:321
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:322
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:323
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:324
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:325
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:326
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:327
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:328
+assert_return(
+  () => invoke($0, `add`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:329
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:330
+assert_return(
+  () => invoke($0, `add`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:331
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:332
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:333
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:334
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:335
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:336
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:337
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:338
+assert_return(
+  () => invoke($0, `add`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:339
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:340
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:341
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:342
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:343
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:344
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:345
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:346
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:347
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:348
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:349
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:350
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:351
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:352
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:353
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:354
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:355
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:356
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:357
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:358
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:359
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:360
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:361
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:362
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:363
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:364
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:365
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:366
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:367
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:368
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:369
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:370
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:371
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:372
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:373
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:374
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:375
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:376
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:377
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:378
+assert_return(
+  () => invoke($0, `add`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:379
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:380
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:381
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:382
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:383
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:384
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:385
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:386
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:387
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:388
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:389
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:390
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:391
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:392
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:393
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:394
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:395
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:396
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:397
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:398
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:399
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:400
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:401
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:402
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:403
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:404
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:405
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:406
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:407
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:408
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:409
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:410
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:411
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:412
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:413
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:414
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:415
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:416
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:417
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:418
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:419
+assert_return(() => invoke($0, `sub`, [value("f32", -0), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:420
+assert_return(() => invoke($0, `sub`, [value("f32", -0), value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:421
+assert_return(() => invoke($0, `sub`, [value("f32", 0), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:422
+assert_return(() => invoke($0, `sub`, [value("f32", 0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:423
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:424
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:425
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:426
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:427
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:428
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:429
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:430
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:431
+assert_return(() => invoke($0, `sub`, [value("f32", -0), value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:432
+assert_return(() => invoke($0, `sub`, [value("f32", -0), value("f32", 0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:433
+assert_return(() => invoke($0, `sub`, [value("f32", 0), value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:434
+assert_return(() => invoke($0, `sub`, [value("f32", 0), value("f32", 0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:435
+assert_return(() => invoke($0, `sub`, [value("f32", -0), value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:436
+assert_return(() => invoke($0, `sub`, [value("f32", -0), value("f32", 1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:437
+assert_return(() => invoke($0, `sub`, [value("f32", 0), value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:438
+assert_return(() => invoke($0, `sub`, [value("f32", 0), value("f32", 1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:439
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), value("f32", -6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:440
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), value("f32", 6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:441
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), value("f32", -6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:442
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), value("f32", 6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:443
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:444
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:445
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:446
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:447
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:448
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:449
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:450
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:451
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:452
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:453
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:454
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:455
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:456
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:457
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:458
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:459
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:460
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:461
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:462
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:463
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:464
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:465
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:466
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:467
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:468
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:469
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:470
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:471
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:472
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:473
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:474
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:475
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:476
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:477
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:478
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:479
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:480
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:481
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:482
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:483
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:484
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:485
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:486
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:487
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:488
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:489
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:490
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:491
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:492
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:493
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:494
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:495
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:496
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:497
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:498
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:499
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:500
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:501
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:502
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:503
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:504
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:505
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754945)],
+);
+
+// ./test/core/f32.wast:506
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/f32.wast:507
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:508
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:509
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:510
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:511
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:512
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:513
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:514
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:515
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:516
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:517
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:518
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:519
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:520
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:521
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:522
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:523
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:524
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:525
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:526
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:527
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:528
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:529
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:530
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:531
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:532
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:533
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:534
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:535
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:536
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:537
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:538
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:539
+assert_return(() => invoke($0, `sub`, [value("f32", -0.5), value("f32", -0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:540
+assert_return(() => invoke($0, `sub`, [value("f32", -0.5), value("f32", 0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:541
+assert_return(() => invoke($0, `sub`, [value("f32", 0.5), value("f32", -0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:542
+assert_return(() => invoke($0, `sub`, [value("f32", 0.5), value("f32", 0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:543
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:544
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:545
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:546
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:547
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:548
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:549
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:550
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:551
+assert_return(() => invoke($0, `sub`, [value("f32", -0.5), value("f32", -0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:552
+assert_return(() => invoke($0, `sub`, [value("f32", -0.5), value("f32", 0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:553
+assert_return(() => invoke($0, `sub`, [value("f32", 0.5), value("f32", -0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:554
+assert_return(() => invoke($0, `sub`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:555
+assert_return(() => invoke($0, `sub`, [value("f32", -0.5), value("f32", -1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:556
+assert_return(() => invoke($0, `sub`, [value("f32", -0.5), value("f32", 1)]), [value("f32", -1.5)]);
+
+// ./test/core/f32.wast:557
+assert_return(() => invoke($0, `sub`, [value("f32", 0.5), value("f32", -1)]), [value("f32", 1.5)]);
+
+// ./test/core/f32.wast:558
+assert_return(() => invoke($0, `sub`, [value("f32", 0.5), value("f32", 1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:559
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", 5.7831855)],
+);
+
+// ./test/core/f32.wast:560
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", -6.7831855)],
+);
+
+// ./test/core/f32.wast:561
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", 6.7831855)],
+);
+
+// ./test/core/f32.wast:562
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", -5.7831855)],
+);
+
+// ./test/core/f32.wast:563
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:564
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:565
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:566
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:567
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:568
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:569
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:570
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:571
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:572
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:573
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:574
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:575
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:576
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:577
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:578
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:579
+assert_return(() => invoke($0, `sub`, [value("f32", -1), value("f32", -0)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:580
+assert_return(() => invoke($0, `sub`, [value("f32", -1), value("f32", 0)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:581
+assert_return(() => invoke($0, `sub`, [value("f32", 1), value("f32", -0)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:582
+assert_return(() => invoke($0, `sub`, [value("f32", 1), value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:583
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:584
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:585
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:586
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:587
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:588
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:589
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:590
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:591
+assert_return(() => invoke($0, `sub`, [value("f32", -1), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:592
+assert_return(() => invoke($0, `sub`, [value("f32", -1), value("f32", 0.5)]), [value("f32", -1.5)]);
+
+// ./test/core/f32.wast:593
+assert_return(() => invoke($0, `sub`, [value("f32", 1), value("f32", -0.5)]), [value("f32", 1.5)]);
+
+// ./test/core/f32.wast:594
+assert_return(() => invoke($0, `sub`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:595
+assert_return(() => invoke($0, `sub`, [value("f32", -1), value("f32", -1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:596
+assert_return(() => invoke($0, `sub`, [value("f32", -1), value("f32", 1)]), [value("f32", -2)]);
+
+// ./test/core/f32.wast:597
+assert_return(() => invoke($0, `sub`, [value("f32", 1), value("f32", -1)]), [value("f32", 2)]);
+
+// ./test/core/f32.wast:598
+assert_return(() => invoke($0, `sub`, [value("f32", 1), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:599
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), value("f32", -6.2831855)]),
+  [value("f32", 5.2831855)],
+);
+
+// ./test/core/f32.wast:600
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), value("f32", 6.2831855)]),
+  [value("f32", -7.2831855)],
+);
+
+// ./test/core/f32.wast:601
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), value("f32", -6.2831855)]),
+  [value("f32", 7.2831855)],
+);
+
+// ./test/core/f32.wast:602
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), value("f32", 6.2831855)]),
+  [value("f32", -5.2831855)],
+);
+
+// ./test/core/f32.wast:603
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:604
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:605
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:606
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:607
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:608
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:609
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:610
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:611
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:612
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:613
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:614
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:615
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:616
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:617
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:618
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:619
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", -0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:620
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", 0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:621
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", -0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:622
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", 0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:623
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:624
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:625
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:626
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:627
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:628
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:629
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:630
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:631
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", -5.7831855)],
+);
+
+// ./test/core/f32.wast:632
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", -6.7831855)],
+);
+
+// ./test/core/f32.wast:633
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", 6.7831855)],
+);
+
+// ./test/core/f32.wast:634
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 5.7831855)],
+);
+
+// ./test/core/f32.wast:635
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", -1)]),
+  [value("f32", -5.2831855)],
+);
+
+// ./test/core/f32.wast:636
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", 1)]),
+  [value("f32", -7.2831855)],
+);
+
+// ./test/core/f32.wast:637
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", -1)]),
+  [value("f32", 7.2831855)],
+);
+
+// ./test/core/f32.wast:638
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", 1)]),
+  [value("f32", 5.2831855)],
+);
+
+// ./test/core/f32.wast:639
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:640
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", -12.566371)],
+);
+
+// ./test/core/f32.wast:641
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", 12.566371)],
+);
+
+// ./test/core/f32.wast:642
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:643
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:644
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:645
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:646
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:647
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:648
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:649
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:650
+assert_return(
+  () => invoke($0, `sub`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:651
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:652
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:653
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:654
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:655
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:656
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:657
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:658
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:659
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:660
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:661
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:662
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:663
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:664
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:665
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:666
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:667
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:668
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:669
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:670
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:671
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:672
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:673
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:674
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:675
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:676
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:677
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:678
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:679
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:680
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:681
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:682
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:683
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:684
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:685
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:686
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:687
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:688
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:689
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:690
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:691
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:692
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:693
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:694
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:695
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:696
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:697
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:698
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:699
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:700
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", 0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:701
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", -0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:702
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:703
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:704
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:705
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:706
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:707
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:708
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:709
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:710
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:711
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:712
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:713
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:714
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:715
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:716
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", 1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:717
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", -1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:718
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:719
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:720
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:721
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:722
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:723
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:724
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:725
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:726
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:727
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:728
+assert_return(
+  () => invoke($0, `sub`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:729
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:730
+assert_return(
+  () => invoke($0, `sub`, [value("f32", Infinity), value("f32", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:731
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:732
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:733
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:734
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:735
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:736
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:737
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:738
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:739
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:740
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:741
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:742
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:743
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:744
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:745
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:746
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:747
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:748
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:749
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:750
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:751
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:752
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:753
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:754
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:755
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:756
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:757
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:758
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:759
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:760
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:761
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:762
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:763
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:764
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:765
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:766
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:767
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:768
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:769
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:770
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:771
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:772
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:773
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:774
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:775
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:776
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:777
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:778
+assert_return(
+  () => invoke($0, `sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:779
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:780
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:781
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:782
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:783
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:784
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:785
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:786
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:787
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:788
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:789
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:790
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:791
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:792
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:793
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:794
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:795
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:796
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:797
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:798
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:799
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:800
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:801
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:802
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:803
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:804
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:805
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:806
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:807
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:808
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:809
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:810
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:811
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:812
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:813
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:814
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:815
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:816
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:817
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:818
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:819
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:820
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:821
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:822
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:823
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:824
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:825
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:826
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:827
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:828
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:829
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:830
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:831
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", -0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:832
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", 0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:833
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:834
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:835
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", -1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:836
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", 1)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:837
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", -1)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:838
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:839
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", -6.2831855)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:840
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", 6.2831855)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:841
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", -6.2831855)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:842
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", 6.2831855)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:843
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:844
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:845
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:846
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:847
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:848
+assert_return(() => invoke($0, `mul`, [value("f32", -0), value("f32", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:849
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:850
+assert_return(() => invoke($0, `mul`, [value("f32", 0), value("f32", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:851
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:852
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:853
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:854
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:855
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:856
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:857
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:858
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:859
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:860
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:861
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:862
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:863
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:864
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:865
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:866
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:867
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:868
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:869
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:870
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:871
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:872
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:873
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:874
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:875
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:876
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:877
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:878
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:879
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:880
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:881
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:882
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:883
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.00000047683713)],
+);
+
+// ./test/core/f32.wast:884
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.00000047683713)],
+);
+
+// ./test/core/f32.wast:885
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.00000047683713)],
+);
+
+// ./test/core/f32.wast:886
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.00000047683713)],
+);
+
+// ./test/core/f32.wast:887
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:888
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:889
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:890
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:891
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:892
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:893
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:894
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:895
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:896
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:897
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:898
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:899
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:900
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:901
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:902
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:903
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:904
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:905
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:906
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:907
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:908
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:909
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:910
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:911
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:912
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:913
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:914
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:915
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:916
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:917
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:918
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:919
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:920
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:921
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:922
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:923
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 3.9999998)],
+);
+
+// ./test/core/f32.wast:924
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -3.9999998)],
+);
+
+// ./test/core/f32.wast:925
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -3.9999998)],
+);
+
+// ./test/core/f32.wast:926
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 3.9999998)],
+);
+
+// ./test/core/f32.wast:927
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:928
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:929
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:930
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:931
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:932
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:933
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:934
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:935
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:936
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:937
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:938
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:939
+assert_return(() => invoke($0, `mul`, [value("f32", -0.5), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:940
+assert_return(() => invoke($0, `mul`, [value("f32", -0.5), value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:941
+assert_return(() => invoke($0, `mul`, [value("f32", 0.5), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:942
+assert_return(() => invoke($0, `mul`, [value("f32", 0.5), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:943
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:944
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:945
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:946
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:947
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:948
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:949
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:950
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000005877472)],
+);
+
+// ./test/core/f32.wast:951
+assert_return(() => invoke($0, `mul`, [value("f32", -0.5), value("f32", -0.5)]), [value("f32", 0.25)]);
+
+// ./test/core/f32.wast:952
+assert_return(() => invoke($0, `mul`, [value("f32", -0.5), value("f32", 0.5)]), [value("f32", -0.25)]);
+
+// ./test/core/f32.wast:953
+assert_return(() => invoke($0, `mul`, [value("f32", 0.5), value("f32", -0.5)]), [value("f32", -0.25)]);
+
+// ./test/core/f32.wast:954
+assert_return(() => invoke($0, `mul`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 0.25)]);
+
+// ./test/core/f32.wast:955
+assert_return(() => invoke($0, `mul`, [value("f32", -0.5), value("f32", -1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:956
+assert_return(() => invoke($0, `mul`, [value("f32", -0.5), value("f32", 1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:957
+assert_return(() => invoke($0, `mul`, [value("f32", 0.5), value("f32", -1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:958
+assert_return(() => invoke($0, `mul`, [value("f32", 0.5), value("f32", 1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:959
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", 3.1415927)],
+);
+
+// ./test/core/f32.wast:960
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", -3.1415927)],
+);
+
+// ./test/core/f32.wast:961
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", -3.1415927)],
+);
+
+// ./test/core/f32.wast:962
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", 3.1415927)],
+);
+
+// ./test/core/f32.wast:963
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:964
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:965
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:966
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:967
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:968
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:969
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:970
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:971
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:972
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:973
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:974
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:975
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:976
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:977
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:978
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:979
+assert_return(() => invoke($0, `mul`, [value("f32", -1), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:980
+assert_return(() => invoke($0, `mul`, [value("f32", -1), value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:981
+assert_return(() => invoke($0, `mul`, [value("f32", 1), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:982
+assert_return(() => invoke($0, `mul`, [value("f32", 1), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:983
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:984
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:985
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:986
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:987
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:988
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:989
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:990
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:991
+assert_return(() => invoke($0, `mul`, [value("f32", -1), value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:992
+assert_return(() => invoke($0, `mul`, [value("f32", -1), value("f32", 0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:993
+assert_return(() => invoke($0, `mul`, [value("f32", 1), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:994
+assert_return(() => invoke($0, `mul`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:995
+assert_return(() => invoke($0, `mul`, [value("f32", -1), value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:996
+assert_return(() => invoke($0, `mul`, [value("f32", -1), value("f32", 1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:997
+assert_return(() => invoke($0, `mul`, [value("f32", 1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:998
+assert_return(() => invoke($0, `mul`, [value("f32", 1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:999
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), value("f32", -6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1000
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), value("f32", 6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1001
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1002
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1003
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1004
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1005
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1006
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1007
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1008
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1009
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1010
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1011
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1012
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1013
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1014
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1015
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1016
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1017
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1018
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1019
+assert_return(() => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1020
+assert_return(() => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1021
+assert_return(() => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1022
+assert_return(() => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1023
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:1024
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:1025
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:1026
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000008)],
+);
+
+// ./test/core/f32.wast:1027
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:1028
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:1029
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:1030
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.00000000000000000000000000000000000007385849)],
+);
+
+// ./test/core/f32.wast:1031
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", 3.1415927)],
+);
+
+// ./test/core/f32.wast:1032
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", -3.1415927)],
+);
+
+// ./test/core/f32.wast:1033
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", -3.1415927)],
+);
+
+// ./test/core/f32.wast:1034
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 3.1415927)],
+);
+
+// ./test/core/f32.wast:1035
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", -1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1036
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", 1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1037
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", -1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1038
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", 1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1039
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", 39.47842)],
+);
+
+// ./test/core/f32.wast:1040
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", -39.47842)],
+);
+
+// ./test/core/f32.wast:1041
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -39.47842)],
+);
+
+// ./test/core/f32.wast:1042
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 39.47842)],
+);
+
+// ./test/core/f32.wast:1043
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1044
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1045
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1046
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1047
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1048
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1049
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1050
+assert_return(
+  () => invoke($0, `mul`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1051
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1052
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1053
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1054
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1055
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1056
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1057
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1058
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1059
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1060
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1061
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1062
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1063
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.00000047683713)],
+);
+
+// ./test/core/f32.wast:1064
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.00000047683713)],
+);
+
+// ./test/core/f32.wast:1065
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.00000047683713)],
+);
+
+// ./test/core/f32.wast:1066
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.00000047683713)],
+);
+
+// ./test/core/f32.wast:1067
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 3.9999998)],
+);
+
+// ./test/core/f32.wast:1068
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -3.9999998)],
+);
+
+// ./test/core/f32.wast:1069
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -3.9999998)],
+);
+
+// ./test/core/f32.wast:1070
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 3.9999998)],
+);
+
+// ./test/core/f32.wast:1071
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1072
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1073
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1074
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 170141170000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1075
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1076
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1077
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1078
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1079
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1080
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1081
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1082
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1083
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1084
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1085
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1086
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1087
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1088
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1089
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1090
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1091
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1092
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1093
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1094
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1095
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1096
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1097
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1098
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1099
+assert_return(() => invoke($0, `mul`, [value("f32", -Infinity), value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1100
+assert_return(() => invoke($0, `mul`, [value("f32", -Infinity), value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1101
+assert_return(() => invoke($0, `mul`, [value("f32", Infinity), value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1102
+assert_return(() => invoke($0, `mul`, [value("f32", Infinity), value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1103
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1104
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1105
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1106
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1107
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1108
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1109
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1110
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1111
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1112
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1113
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1114
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1115
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", -1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1116
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", 1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1117
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1118
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1119
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1120
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1121
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1122
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1123
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1124
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1125
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1126
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1127
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1128
+assert_return(
+  () => invoke($0, `mul`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1129
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1130
+assert_return(
+  () => invoke($0, `mul`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1131
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1132
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1133
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1134
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1135
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1136
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1137
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1138
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1139
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1140
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1141
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1142
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1143
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1144
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1145
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1146
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1147
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1148
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1149
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1150
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1151
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1152
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1153
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1154
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1155
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1156
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1157
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1158
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1159
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1160
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1161
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1162
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1163
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1164
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1165
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1166
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1167
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1168
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1169
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1170
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1171
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1172
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1173
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1174
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1175
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1176
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1177
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1178
+assert_return(
+  () => invoke($0, `mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1179
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1180
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1181
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1182
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1183
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1184
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1185
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1186
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1187
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1188
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1189
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1190
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1191
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1192
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1193
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1194
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1195
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1196
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1197
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1198
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1199
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1200
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1201
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1202
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1203
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1204
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1205
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1206
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1207
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1208
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1209
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1210
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1211
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1212
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1213
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1214
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1215
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1216
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1217
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1218
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1219
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1220
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1221
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1222
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:1223
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1224
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1225
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1226
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1227
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1228
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1229
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1230
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1231
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", -0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1232
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", 0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1233
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1234
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1235
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", -1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1236
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", 1)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1237
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", -1)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1238
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1239
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", -6.2831855)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1240
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", 6.2831855)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1241
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", -6.2831855)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1242
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", 6.2831855)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1243
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1244
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1245
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1246
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1247
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", -Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1248
+assert_return(() => invoke($0, `div`, [value("f32", -0), value("f32", Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1249
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", -Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1250
+assert_return(() => invoke($0, `div`, [value("f32", 0), value("f32", Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1251
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1252
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1253
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1254
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1255
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1256
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1257
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1258
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1259
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1260
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1261
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1262
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1263
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1264
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1265
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1266
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1267
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.00000011920929)],
+);
+
+// ./test/core/f32.wast:1268
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.00000011920929)],
+);
+
+// ./test/core/f32.wast:1269
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.00000011920929)],
+);
+
+// ./test/core/f32.wast:1270
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.00000011920929)],
+);
+
+// ./test/core/f32.wast:1271
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:1272
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:1273
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:1274
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/f32.wast:1275
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1276
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1277
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1278
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1279
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1280
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1281
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1282
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1283
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1284
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1285
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1286
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1287
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1288
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1289
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1290
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1291
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1292
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1293
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1294
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1295
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1296
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1297
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1298
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1299
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1300
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1301
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1302
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1303
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 8388608)],
+);
+
+// ./test/core/f32.wast:1304
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -8388608)],
+);
+
+// ./test/core/f32.wast:1305
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -8388608)],
+);
+
+// ./test/core/f32.wast:1306
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 8388608)],
+);
+
+// ./test/core/f32.wast:1307
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1308
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1309
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1310
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1311
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:1312
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:1313
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:1314
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/f32.wast:1315
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1316
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1317
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1318
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1319
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000001870857)],
+);
+
+// ./test/core/f32.wast:1320
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000001870857)],
+);
+
+// ./test/core/f32.wast:1321
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000001870857)],
+);
+
+// ./test/core/f32.wast:1322
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000001870857)],
+);
+
+// ./test/core/f32.wast:1323
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1324
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1325
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1326
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1327
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1328
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1329
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1330
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1331
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1332
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1333
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1334
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1335
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1336
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1337
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1338
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1339
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", -0)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:1340
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", 0)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:1341
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", -0)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:1342
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", 0)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:1343
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1344
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1345
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1346
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1347
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 42535296000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1348
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -42535296000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1349
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -42535296000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1350
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 42535296000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1351
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", -0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1352
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", 0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1353
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", -0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1354
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1355
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", -1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1356
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", 1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1357
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", -1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1358
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", 1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1359
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", 0.07957747)],
+);
+
+// ./test/core/f32.wast:1360
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", -0.07957747)],
+);
+
+// ./test/core/f32.wast:1361
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", -0.07957747)],
+);
+
+// ./test/core/f32.wast:1362
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", 0.07957747)],
+);
+
+// ./test/core/f32.wast:1363
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000001469368)],
+);
+
+// ./test/core/f32.wast:1364
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000001469368)],
+);
+
+// ./test/core/f32.wast:1365
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000001469368)],
+);
+
+// ./test/core/f32.wast:1366
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000001469368)],
+);
+
+// ./test/core/f32.wast:1367
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", -Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1368
+assert_return(() => invoke($0, `div`, [value("f32", -0.5), value("f32", Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1369
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", -Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1370
+assert_return(() => invoke($0, `div`, [value("f32", 0.5), value("f32", Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1371
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1372
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1373
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1374
+assert_return(
+  () => invoke($0, `div`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1375
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1376
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1377
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1378
+assert_return(
+  () => invoke($0, `div`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1379
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", -0)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:1380
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", 0)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:1381
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", -0)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:1382
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", 0)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:1383
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1384
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1385
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1386
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1387
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 85070590000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1388
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -85070590000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1389
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -85070590000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1390
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 85070590000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1391
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", -0.5)]), [value("f32", 2)]);
+
+// ./test/core/f32.wast:1392
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", 0.5)]), [value("f32", -2)]);
+
+// ./test/core/f32.wast:1393
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", -0.5)]), [value("f32", -2)]);
+
+// ./test/core/f32.wast:1394
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 2)]);
+
+// ./test/core/f32.wast:1395
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1396
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", 1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1397
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1398
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1399
+assert_return(
+  () => invoke($0, `div`, [value("f32", -1), value("f32", -6.2831855)]),
+  [value("f32", 0.15915494)],
+);
+
+// ./test/core/f32.wast:1400
+assert_return(
+  () => invoke($0, `div`, [value("f32", -1), value("f32", 6.2831855)]),
+  [value("f32", -0.15915494)],
+);
+
+// ./test/core/f32.wast:1401
+assert_return(
+  () => invoke($0, `div`, [value("f32", 1), value("f32", -6.2831855)]),
+  [value("f32", -0.15915494)],
+);
+
+// ./test/core/f32.wast:1402
+assert_return(
+  () => invoke($0, `div`, [value("f32", 1), value("f32", 6.2831855)]),
+  [value("f32", 0.15915494)],
+);
+
+// ./test/core/f32.wast:1403
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000002938736)],
+);
+
+// ./test/core/f32.wast:1404
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000002938736)],
+);
+
+// ./test/core/f32.wast:1405
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000002938736)],
+);
+
+// ./test/core/f32.wast:1406
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000002938736)],
+);
+
+// ./test/core/f32.wast:1407
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", -Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1408
+assert_return(() => invoke($0, `div`, [value("f32", -1), value("f32", Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1409
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", -Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1410
+assert_return(() => invoke($0, `div`, [value("f32", 1), value("f32", Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1411
+assert_return(
+  () => invoke($0, `div`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1412
+assert_return(
+  () => invoke($0, `div`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1413
+assert_return(
+  () => invoke($0, `div`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1414
+assert_return(
+  () => invoke($0, `div`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1415
+assert_return(
+  () => invoke($0, `div`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1416
+assert_return(
+  () => invoke($0, `div`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1417
+assert_return(
+  () => invoke($0, `div`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1418
+assert_return(
+  () => invoke($0, `div`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1419
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", -0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1420
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", 0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1421
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1422
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1423
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1424
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1425
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1426
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1427
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1428
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1429
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1430
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1431
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", 12.566371)],
+);
+
+// ./test/core/f32.wast:1432
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", -12.566371)],
+);
+
+// ./test/core/f32.wast:1433
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", -12.566371)],
+);
+
+// ./test/core/f32.wast:1434
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 12.566371)],
+);
+
+// ./test/core/f32.wast:1435
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", -1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1436
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", 1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1437
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", -1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1438
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", 1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1439
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1440
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1441
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1442
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1443
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000018464624)],
+);
+
+// ./test/core/f32.wast:1444
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000018464624)],
+);
+
+// ./test/core/f32.wast:1445
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000018464624)],
+);
+
+// ./test/core/f32.wast:1446
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000018464624)],
+);
+
+// ./test/core/f32.wast:1447
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1448
+assert_return(
+  () => invoke($0, `div`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1449
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1450
+assert_return(
+  () => invoke($0, `div`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1451
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1452
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1453
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1454
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1455
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1456
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1457
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1458
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1459
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1460
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1461
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1462
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1463
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1464
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1465
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1466
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1467
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1468
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1469
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1470
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1471
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1472
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1473
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1474
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1475
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1476
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1477
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1478
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1479
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 54157613000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1480
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -54157613000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1481
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -54157613000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1482
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 54157613000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1483
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1484
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1485
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1486
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1487
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1488
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1489
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1490
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1491
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1492
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1493
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1494
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1495
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1496
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1497
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1498
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1499
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", -0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1500
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", 0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1501
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1502
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1503
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1504
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1505
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1506
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1507
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1508
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1509
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1510
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1511
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1512
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1513
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1514
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1515
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", -1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1516
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", 1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1517
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1518
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1519
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1520
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1521
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1522
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1523
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1524
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1525
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1526
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1527
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1528
+assert_return(
+  () => invoke($0, `div`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1529
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1530
+assert_return(
+  () => invoke($0, `div`, [value("f32", Infinity), value("f32", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1531
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1532
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1533
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1534
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1535
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1536
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1537
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1538
+assert_return(
+  () => invoke($0, `div`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1539
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1540
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1541
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1542
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1543
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1544
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1545
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1546
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1547
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1548
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1549
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1550
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1551
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1552
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1553
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1554
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1555
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1556
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1557
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1558
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1559
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1560
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1561
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1562
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1563
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1564
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1565
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1566
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1567
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1568
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1569
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1570
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1571
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1572
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1573
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1574
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1575
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1576
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1577
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1578
+assert_return(
+  () => invoke($0, `div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1579
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1580
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1581
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1582
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1583
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1584
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1585
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1586
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1587
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1588
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1589
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1590
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1591
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1592
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1593
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1594
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1595
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1596
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1597
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1598
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1599
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1600
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1601
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1602
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1603
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1604
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1605
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1606
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1607
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1608
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1609
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1610
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1611
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1612
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1613
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1614
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1615
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1616
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1617
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1618
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1619
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1620
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1621
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1622
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1623
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1624
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1625
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1626
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1627
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1628
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1629
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1630
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1631
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1632
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", 0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1633
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1634
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1635
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1636
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", 1)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1637
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1638
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1639
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1640
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", 6.2831855)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1641
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1642
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", 6.2831855)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1643
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1644
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1645
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1646
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1647
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1648
+assert_return(() => invoke($0, `min`, [value("f32", -0), value("f32", Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1649
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1650
+assert_return(() => invoke($0, `min`, [value("f32", 0), value("f32", Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1651
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1652
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1653
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1654
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1655
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1656
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1657
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1658
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1659
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1660
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1661
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1662
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1663
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1664
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1665
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1666
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1667
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1668
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1669
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1670
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1671
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1672
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1673
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1674
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1675
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1676
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1677
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1678
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1679
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1680
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1681
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1682
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1683
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1684
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1685
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1686
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1687
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1688
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1689
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1690
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1691
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1692
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1693
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1694
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1695
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1696
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1697
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1698
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1699
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1700
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1701
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1702
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1703
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1704
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1705
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1706
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1707
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1708
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1709
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1710
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1711
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1712
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1713
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1714
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1715
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1716
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1717
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1718
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1719
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1720
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1721
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1722
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1723
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1724
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1725
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1726
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1727
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1728
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1729
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1730
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1731
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1732
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1733
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1734
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1735
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1736
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1737
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1738
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1739
+assert_return(() => invoke($0, `min`, [value("f32", -0.5), value("f32", -0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1740
+assert_return(() => invoke($0, `min`, [value("f32", -0.5), value("f32", 0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1741
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1742
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1743
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1744
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1745
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1746
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1747
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1748
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1749
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1750
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1751
+assert_return(() => invoke($0, `min`, [value("f32", -0.5), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1752
+assert_return(() => invoke($0, `min`, [value("f32", -0.5), value("f32", 0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1753
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1754
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1755
+assert_return(() => invoke($0, `min`, [value("f32", -0.5), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1756
+assert_return(() => invoke($0, `min`, [value("f32", -0.5), value("f32", 1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1757
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1758
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", 1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1759
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1760
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1761
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1762
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:1763
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1764
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1765
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1766
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:1767
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1768
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), value("f32", Infinity)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1769
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1770
+assert_return(() => invoke($0, `min`, [value("f32", 0.5), value("f32", Infinity)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1771
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1772
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1773
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1774
+assert_return(
+  () => invoke($0, `min`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1775
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1776
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1777
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1778
+assert_return(
+  () => invoke($0, `min`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1779
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", -0)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1780
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", 0)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1781
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1782
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1783
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1784
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1785
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1786
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1787
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1788
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1789
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1790
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1791
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", -0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1792
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", 0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1793
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:1794
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1795
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1796
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", 1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1797
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1798
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1799
+assert_return(
+  () => invoke($0, `min`, [value("f32", -1), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1800
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", 6.2831855)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1801
+assert_return(
+  () => invoke($0, `min`, [value("f32", 1), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1802
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", 6.2831855)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1803
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1804
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1805
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1806
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1807
+assert_return(
+  () => invoke($0, `min`, [value("f32", -1), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1808
+assert_return(() => invoke($0, `min`, [value("f32", -1), value("f32", Infinity)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1809
+assert_return(
+  () => invoke($0, `min`, [value("f32", 1), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1810
+assert_return(() => invoke($0, `min`, [value("f32", 1), value("f32", Infinity)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1811
+assert_return(
+  () => invoke($0, `min`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1812
+assert_return(
+  () => invoke($0, `min`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1813
+assert_return(
+  () => invoke($0, `min`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1814
+assert_return(
+  () => invoke($0, `min`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1815
+assert_return(
+  () => invoke($0, `min`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1816
+assert_return(
+  () => invoke($0, `min`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1817
+assert_return(
+  () => invoke($0, `min`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1818
+assert_return(
+  () => invoke($0, `min`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1819
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", -0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1820
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", 0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1821
+assert_return(() => invoke($0, `min`, [value("f32", 6.2831855), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1822
+assert_return(() => invoke($0, `min`, [value("f32", 6.2831855), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1823
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1824
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1825
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1826
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1827
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1828
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1829
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1830
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1831
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1832
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1833
+assert_return(
+  () => invoke($0, `min`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1834
+assert_return(
+  () => invoke($0, `min`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:1835
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", -1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1836
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", 1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1837
+assert_return(() => invoke($0, `min`, [value("f32", 6.2831855), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1838
+assert_return(() => invoke($0, `min`, [value("f32", 6.2831855), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1839
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1840
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1841
+assert_return(
+  () => invoke($0, `min`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1842
+assert_return(
+  () => invoke($0, `min`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1843
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1844
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1845
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1846
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1847
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1848
+assert_return(
+  () => invoke($0, `min`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1849
+assert_return(
+  () => invoke($0, `min`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1850
+assert_return(
+  () => invoke($0, `min`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1851
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1852
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1853
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1854
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1855
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1856
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1857
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1858
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1859
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1860
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1861
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:1862
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:1863
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1864
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1865
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1866
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1867
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1868
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1869
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1870
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1871
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1872
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1873
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1874
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:1875
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1876
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1877
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:1878
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:1879
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1880
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1881
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1882
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1883
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1884
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1885
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1886
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1887
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1888
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1889
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1890
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1891
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1892
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1893
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1894
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1895
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1896
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1897
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1898
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1899
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1900
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", 0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1901
+assert_return(() => invoke($0, `min`, [value("f32", Infinity), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:1902
+assert_return(() => invoke($0, `min`, [value("f32", Infinity), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:1903
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1904
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1905
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1906
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:1907
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1908
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1909
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1910
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:1911
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1912
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1913
+assert_return(
+  () => invoke($0, `min`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:1914
+assert_return(() => invoke($0, `min`, [value("f32", Infinity), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:1915
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1916
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", 1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1917
+assert_return(() => invoke($0, `min`, [value("f32", Infinity), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:1918
+assert_return(() => invoke($0, `min`, [value("f32", Infinity), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:1919
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1920
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1921
+assert_return(
+  () => invoke($0, `min`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:1922
+assert_return(
+  () => invoke($0, `min`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:1923
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1924
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1925
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1926
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:1927
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1928
+assert_return(
+  () => invoke($0, `min`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1929
+assert_return(
+  () => invoke($0, `min`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:1930
+assert_return(
+  () => invoke($0, `min`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:1931
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1932
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1933
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1934
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1935
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1936
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1937
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1938
+assert_return(
+  () => invoke($0, `min`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1939
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1940
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1941
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1942
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1943
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1944
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1945
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1946
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1947
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1948
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1949
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1950
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1951
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1952
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1953
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1954
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1955
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1956
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1957
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1958
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1959
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1960
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1961
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1962
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1963
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1964
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1965
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1966
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1967
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1968
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1969
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1970
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1971
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1972
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1973
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1974
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1975
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1976
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1977
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1978
+assert_return(
+  () => invoke($0, `min`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1979
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1980
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1981
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1982
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1983
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1984
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1985
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1986
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1987
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1988
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1989
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1990
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1991
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1992
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1993
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1994
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1995
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1996
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1997
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:1998
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:1999
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2000
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2001
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2002
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2003
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2004
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2005
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2006
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2007
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2008
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2009
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2010
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2011
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2012
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2013
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2014
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2015
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2016
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2017
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2018
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2019
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2020
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2021
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2022
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2023
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2024
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2025
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2026
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2027
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2028
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2029
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2030
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2031
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2032
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2033
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", -0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2034
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2035
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", -1)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2036
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2037
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", -1)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2038
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2039
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", -6.2831855)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2040
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2041
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", -6.2831855)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2042
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2043
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2044
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2045
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2046
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2047
+assert_return(() => invoke($0, `max`, [value("f32", -0), value("f32", -Infinity)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2048
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2049
+assert_return(() => invoke($0, `max`, [value("f32", 0), value("f32", -Infinity)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2050
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2051
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2052
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2053
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2054
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2055
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2056
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2057
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2058
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2059
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2060
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2061
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2062
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2063
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2064
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2065
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2066
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2067
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2068
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2069
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2070
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2071
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2072
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2073
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2074
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2075
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2076
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2077
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2078
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2079
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2080
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2081
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2082
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2083
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2084
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2085
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2086
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2087
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2088
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2089
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2090
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2091
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2092
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2093
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2094
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2095
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2096
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2097
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2098
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2099
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2100
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2101
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2102
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2103
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2104
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2105
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2106
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2107
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2108
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2109
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2110
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2111
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2112
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2113
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2114
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2115
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2116
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2117
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2118
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2119
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2120
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2121
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2122
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2123
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2124
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2125
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2126
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2127
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2128
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2129
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2130
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2131
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2132
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2133
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2134
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2135
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2136
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2137
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2138
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2139
+assert_return(() => invoke($0, `max`, [value("f32", -0.5), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2140
+assert_return(() => invoke($0, `max`, [value("f32", -0.5), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2141
+assert_return(() => invoke($0, `max`, [value("f32", 0.5), value("f32", -0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2142
+assert_return(() => invoke($0, `max`, [value("f32", 0.5), value("f32", 0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2143
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2144
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2145
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2146
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2147
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2148
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2149
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2150
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2151
+assert_return(() => invoke($0, `max`, [value("f32", -0.5), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:2152
+assert_return(() => invoke($0, `max`, [value("f32", -0.5), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2153
+assert_return(() => invoke($0, `max`, [value("f32", 0.5), value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2154
+assert_return(() => invoke($0, `max`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2155
+assert_return(() => invoke($0, `max`, [value("f32", -0.5), value("f32", -1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:2156
+assert_return(() => invoke($0, `max`, [value("f32", -0.5), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2157
+assert_return(() => invoke($0, `max`, [value("f32", 0.5), value("f32", -1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2158
+assert_return(() => invoke($0, `max`, [value("f32", 0.5), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2159
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:2160
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2161
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2162
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2163
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:2164
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2165
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2166
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2167
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), value("f32", -Infinity)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:2168
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2169
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), value("f32", -Infinity)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2170
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2171
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2172
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2173
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2174
+assert_return(
+  () => invoke($0, `max`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2175
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2176
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2177
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2178
+assert_return(
+  () => invoke($0, `max`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2179
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2180
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2181
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", -0)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2182
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2183
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2184
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2185
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2186
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2187
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2188
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2189
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2190
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2191
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", -0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32.wast:2192
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32.wast:2193
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", -0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2194
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2195
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2196
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2197
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2198
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2199
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", -6.2831855)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2200
+assert_return(
+  () => invoke($0, `max`, [value("f32", -1), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2201
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", -6.2831855)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2202
+assert_return(
+  () => invoke($0, `max`, [value("f32", 1), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2203
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:2204
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2205
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2206
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2207
+assert_return(() => invoke($0, `max`, [value("f32", -1), value("f32", -Infinity)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2208
+assert_return(
+  () => invoke($0, `max`, [value("f32", -1), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2209
+assert_return(() => invoke($0, `max`, [value("f32", 1), value("f32", -Infinity)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2210
+assert_return(
+  () => invoke($0, `max`, [value("f32", 1), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2211
+assert_return(
+  () => invoke($0, `max`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2212
+assert_return(
+  () => invoke($0, `max`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2213
+assert_return(
+  () => invoke($0, `max`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2214
+assert_return(
+  () => invoke($0, `max`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2215
+assert_return(
+  () => invoke($0, `max`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2216
+assert_return(
+  () => invoke($0, `max`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2217
+assert_return(
+  () => invoke($0, `max`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2218
+assert_return(
+  () => invoke($0, `max`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2219
+assert_return(() => invoke($0, `max`, [value("f32", -6.2831855), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2220
+assert_return(() => invoke($0, `max`, [value("f32", -6.2831855), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2221
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", -0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2222
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", 0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2223
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2224
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2225
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2226
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2227
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2228
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2229
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2230
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2231
+assert_return(
+  () => invoke($0, `max`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:2232
+assert_return(
+  () => invoke($0, `max`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2233
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2234
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2235
+assert_return(() => invoke($0, `max`, [value("f32", -6.2831855), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2236
+assert_return(() => invoke($0, `max`, [value("f32", -6.2831855), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2237
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", -1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2238
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", 1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2239
+assert_return(
+  () => invoke($0, `max`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:2240
+assert_return(
+  () => invoke($0, `max`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2241
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2242
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2243
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:2244
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2245
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2246
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2247
+assert_return(
+  () => invoke($0, `max`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:2248
+assert_return(
+  () => invoke($0, `max`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2249
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2250
+assert_return(
+  () => invoke($0, `max`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2251
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2252
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2253
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2254
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2255
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2256
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2257
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2258
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2259
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2260
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2261
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2262
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2263
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2264
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2265
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2266
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2267
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2268
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2269
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2270
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2271
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:2272
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2273
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2274
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2275
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:2276
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2277
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2278
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2279
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:2280
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2281
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2282
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2283
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2284
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2285
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2286
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2287
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2288
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2289
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2290
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2291
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2292
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2293
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2294
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2295
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2296
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2297
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2298
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2299
+assert_return(() => invoke($0, `max`, [value("f32", -Infinity), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2300
+assert_return(() => invoke($0, `max`, [value("f32", -Infinity), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2301
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", -0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2302
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2303
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2304
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32.wast:2305
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2306
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2307
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2308
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32.wast:2309
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2310
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2311
+assert_return(
+  () => invoke($0, `max`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32.wast:2312
+assert_return(
+  () => invoke($0, `max`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32.wast:2313
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2314
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2315
+assert_return(() => invoke($0, `max`, [value("f32", -Infinity), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2316
+assert_return(() => invoke($0, `max`, [value("f32", -Infinity), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2317
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", -1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2318
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2319
+assert_return(
+  () => invoke($0, `max`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32.wast:2320
+assert_return(
+  () => invoke($0, `max`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32.wast:2321
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2322
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2323
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2324
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2325
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2326
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2327
+assert_return(
+  () => invoke($0, `max`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32.wast:2328
+assert_return(
+  () => invoke($0, `max`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2329
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2330
+assert_return(
+  () => invoke($0, `max`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32.wast:2331
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2332
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2333
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2334
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2335
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2336
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2337
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2338
+assert_return(
+  () => invoke($0, `max`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2339
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2340
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2341
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2342
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2343
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2344
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2345
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2346
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2347
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2348
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2349
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2350
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2351
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2352
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2353
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2354
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2355
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2356
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2357
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2358
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2359
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2360
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2361
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2362
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2363
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2364
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2365
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2366
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2367
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2368
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2369
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2370
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2371
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2372
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2373
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2374
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2375
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2376
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2377
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2378
+assert_return(
+  () => invoke($0, `max`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2379
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2380
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2381
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2382
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2383
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2384
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2385
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2386
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2387
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2388
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2389
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2390
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2391
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2392
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2393
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2394
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2395
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2396
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2397
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2398
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2399
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2400
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2401
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2402
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2403
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2404
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2405
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2406
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2407
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2408
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2409
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2410
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2411
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2412
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2413
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2414
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2415
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2416
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2417
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2418
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f32.wast:2419
+assert_return(() => invoke($0, `sqrt`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2420
+assert_return(() => invoke($0, `sqrt`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2421
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2422
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.00000000000000000000003743392)],
+);
+
+// ./test/core/f32.wast:2423
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2424
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.00000000000000000010842022)],
+);
+
+// ./test/core/f32.wast:2425
+assert_return(() => invoke($0, `sqrt`, [value("f32", -0.5)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2426
+assert_return(() => invoke($0, `sqrt`, [value("f32", 0.5)]), [value("f32", 0.70710677)]);
+
+// ./test/core/f32.wast:2427
+assert_return(() => invoke($0, `sqrt`, [value("f32", -1)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2428
+assert_return(() => invoke($0, `sqrt`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2429
+assert_return(() => invoke($0, `sqrt`, [value("f32", -6.2831855)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2430
+assert_return(() => invoke($0, `sqrt`, [value("f32", 6.2831855)]), [value("f32", 2.5066283)]);
+
+// ./test/core/f32.wast:2431
+assert_return(
+  () => invoke($0, `sqrt`, [value("f32", -340282350000000000000000000000000000000)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f32.wast:2432
+assert_return(
+  () => invoke($0, `sqrt`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 18446743000000000000)],
+);
+
+// ./test/core/f32.wast:2433
+assert_return(() => invoke($0, `sqrt`, [value("f32", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2434
+assert_return(() => invoke($0, `sqrt`, [value("f32", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:2435
+assert_return(() => invoke($0, `sqrt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2436
+assert_return(() => invoke($0, `sqrt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2437
+assert_return(() => invoke($0, `sqrt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2438
+assert_return(() => invoke($0, `sqrt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2439
+assert_return(() => invoke($0, `floor`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2440
+assert_return(() => invoke($0, `floor`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2441
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:2442
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2443
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32.wast:2444
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2445
+assert_return(() => invoke($0, `floor`, [value("f32", -0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2446
+assert_return(() => invoke($0, `floor`, [value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2447
+assert_return(() => invoke($0, `floor`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2448
+assert_return(() => invoke($0, `floor`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2449
+assert_return(() => invoke($0, `floor`, [value("f32", -6.2831855)]), [value("f32", -7)]);
+
+// ./test/core/f32.wast:2450
+assert_return(() => invoke($0, `floor`, [value("f32", 6.2831855)]), [value("f32", 6)]);
+
+// ./test/core/f32.wast:2451
+assert_return(
+  () => invoke($0, `floor`, [value("f32", -340282350000000000000000000000000000000)]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2452
+assert_return(
+  () => invoke($0, `floor`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2453
+assert_return(() => invoke($0, `floor`, [value("f32", -Infinity)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:2454
+assert_return(() => invoke($0, `floor`, [value("f32", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:2455
+assert_return(() => invoke($0, `floor`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2456
+assert_return(() => invoke($0, `floor`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2457
+assert_return(() => invoke($0, `floor`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2458
+assert_return(() => invoke($0, `floor`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2459
+assert_return(() => invoke($0, `ceil`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2460
+assert_return(() => invoke($0, `ceil`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2461
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2462
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2463
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2464
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32.wast:2465
+assert_return(() => invoke($0, `ceil`, [value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2466
+assert_return(() => invoke($0, `ceil`, [value("f32", 0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2467
+assert_return(() => invoke($0, `ceil`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2468
+assert_return(() => invoke($0, `ceil`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2469
+assert_return(() => invoke($0, `ceil`, [value("f32", -6.2831855)]), [value("f32", -6)]);
+
+// ./test/core/f32.wast:2470
+assert_return(() => invoke($0, `ceil`, [value("f32", 6.2831855)]), [value("f32", 7)]);
+
+// ./test/core/f32.wast:2471
+assert_return(
+  () => invoke($0, `ceil`, [value("f32", -340282350000000000000000000000000000000)]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2472
+assert_return(
+  () => invoke($0, `ceil`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2473
+assert_return(() => invoke($0, `ceil`, [value("f32", -Infinity)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:2474
+assert_return(() => invoke($0, `ceil`, [value("f32", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:2475
+assert_return(() => invoke($0, `ceil`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2476
+assert_return(() => invoke($0, `ceil`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2477
+assert_return(() => invoke($0, `ceil`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2478
+assert_return(() => invoke($0, `ceil`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2479
+assert_return(() => invoke($0, `trunc`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2480
+assert_return(() => invoke($0, `trunc`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2481
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2482
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2483
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2484
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2485
+assert_return(() => invoke($0, `trunc`, [value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2486
+assert_return(() => invoke($0, `trunc`, [value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2487
+assert_return(() => invoke($0, `trunc`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2488
+assert_return(() => invoke($0, `trunc`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2489
+assert_return(() => invoke($0, `trunc`, [value("f32", -6.2831855)]), [value("f32", -6)]);
+
+// ./test/core/f32.wast:2490
+assert_return(() => invoke($0, `trunc`, [value("f32", 6.2831855)]), [value("f32", 6)]);
+
+// ./test/core/f32.wast:2491
+assert_return(
+  () => invoke($0, `trunc`, [value("f32", -340282350000000000000000000000000000000)]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2492
+assert_return(
+  () => invoke($0, `trunc`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2493
+assert_return(() => invoke($0, `trunc`, [value("f32", -Infinity)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:2494
+assert_return(() => invoke($0, `trunc`, [value("f32", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:2495
+assert_return(() => invoke($0, `trunc`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2496
+assert_return(() => invoke($0, `trunc`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2497
+assert_return(() => invoke($0, `trunc`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2498
+assert_return(() => invoke($0, `trunc`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2499
+assert_return(() => invoke($0, `nearest`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2500
+assert_return(() => invoke($0, `nearest`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2501
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2502
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2503
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32.wast:2504
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32.wast:2505
+assert_return(() => invoke($0, `nearest`, [value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32.wast:2506
+assert_return(() => invoke($0, `nearest`, [value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32.wast:2507
+assert_return(() => invoke($0, `nearest`, [value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32.wast:2508
+assert_return(() => invoke($0, `nearest`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32.wast:2509
+assert_return(() => invoke($0, `nearest`, [value("f32", -6.2831855)]), [value("f32", -6)]);
+
+// ./test/core/f32.wast:2510
+assert_return(() => invoke($0, `nearest`, [value("f32", 6.2831855)]), [value("f32", 6)]);
+
+// ./test/core/f32.wast:2511
+assert_return(
+  () => invoke($0, `nearest`, [value("f32", -340282350000000000000000000000000000000)]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2512
+assert_return(
+  () => invoke($0, `nearest`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32.wast:2513
+assert_return(() => invoke($0, `nearest`, [value("f32", -Infinity)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32.wast:2514
+assert_return(() => invoke($0, `nearest`, [value("f32", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32.wast:2515
+assert_return(() => invoke($0, `nearest`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2516
+assert_return(() => invoke($0, `nearest`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2517
+assert_return(() => invoke($0, `nearest`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]), [`canonical_nan`]);
+
+// ./test/core/f32.wast:2518
+assert_return(() => invoke($0, `nearest`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]), [`arithmetic_nan`]);
+
+// ./test/core/f32.wast:2523
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.add (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2524
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.div (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2525
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.max (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2526
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.min (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2527
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.mul (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2528
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.sub (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2529
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.ceil (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2530
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.floor (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2531
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.nearest (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2532
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.sqrt (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2533
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.trunc (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32.wast:2536
+assert_malformed(
+  () => instantiate(`(func (result f32) (f32.const nan:arithmetic)) `),
+  `unexpected token`,
+);
+
+// ./test/core/f32.wast:2540
+assert_malformed(
+  () => instantiate(`(func (result f32) (f32.const nan:canonical)) `),
+  `unexpected token`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/f32_bitwise.wast.js b/js/src/jit-test/tests/wasm/spec/spec/f32_bitwise.wast.js
new file mode 100644
index 0000000000..7a27263671
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/f32_bitwise.wast.js
@@ -0,0 +1,2688 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/f32_bitwise.wast
+
+// ./test/core/f32_bitwise.wast:4
+let $0 = instantiate(`(module
+  (func (export "abs") (param $$x f32) (result f32) (f32.abs (local.get $$x)))
+  (func (export "neg") (param $$x f32) (result f32) (f32.neg (local.get $$x)))
+  (func (export "copysign") (param $$x f32) (param $$y f32) (result f32) (f32.copysign (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/f32_bitwise.wast:10
+assert_return(() => invoke($0, `copysign`, [value("f32", -0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:11
+assert_return(() => invoke($0, `copysign`, [value("f32", -0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:12
+assert_return(() => invoke($0, `copysign`, [value("f32", 0), value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:13
+assert_return(() => invoke($0, `copysign`, [value("f32", 0), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:14
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:15
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:16
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:17
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:18
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:19
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:20
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:21
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:22
+assert_return(() => invoke($0, `copysign`, [value("f32", -0), value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:23
+assert_return(() => invoke($0, `copysign`, [value("f32", -0), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:24
+assert_return(() => invoke($0, `copysign`, [value("f32", 0), value("f32", -0.5)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:25
+assert_return(() => invoke($0, `copysign`, [value("f32", 0), value("f32", 0.5)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:26
+assert_return(() => invoke($0, `copysign`, [value("f32", -0), value("f32", -1)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:27
+assert_return(() => invoke($0, `copysign`, [value("f32", -0), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:28
+assert_return(() => invoke($0, `copysign`, [value("f32", 0), value("f32", -1)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:29
+assert_return(() => invoke($0, `copysign`, [value("f32", 0), value("f32", 1)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:30
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0), value("f32", -6.2831855)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:31
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0), value("f32", 6.2831855)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:32
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0), value("f32", -6.2831855)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:33
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0), value("f32", 6.2831855)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:34
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:35
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:36
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:37
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:38
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0), value("f32", -Infinity)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:39
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0), value("f32", Infinity)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:40
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0), value("f32", -Infinity)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:41
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0), value("f32", Infinity)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:42
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:43
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:44
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("f32", -0)],
+);
+
+// ./test/core/f32_bitwise.wast:45
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("f32", 0)],
+);
+
+// ./test/core/f32_bitwise.wast:46
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:47
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:48
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:49
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:50
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:51
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:52
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:53
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:54
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:55
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:56
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:57
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:58
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:59
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:60
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:61
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:62
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:63
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:64
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:65
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:66
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:67
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:68
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:69
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:70
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:71
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:72
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:73
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:74
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:75
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:76
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:77
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:78
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:79
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:80
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:81
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:82
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:83
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:84
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:85
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:86
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:87
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:88
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:89
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:90
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:91
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:92
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:93
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:94
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:95
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:96
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:97
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:98
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:99
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:100
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:101
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:102
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:103
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:104
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:105
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:106
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:107
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:108
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:109
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:110
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:111
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:112
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:113
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:114
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:115
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:116
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:117
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:118
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", -0)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:119
+assert_return(() => invoke($0, `copysign`, [value("f32", -0.5), value("f32", 0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:120
+assert_return(() => invoke($0, `copysign`, [value("f32", 0.5), value("f32", -0)]), [value("f32", -0.5)]);
+
+// ./test/core/f32_bitwise.wast:121
+assert_return(() => invoke($0, `copysign`, [value("f32", 0.5), value("f32", 0)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:122
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:123
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:124
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:125
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:126
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:127
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:128
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:129
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:130
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", -0.5)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:131
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", 0.5)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:132
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0.5), value("f32", -0.5)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:133
+assert_return(() => invoke($0, `copysign`, [value("f32", 0.5), value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:134
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", -1)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:135
+assert_return(() => invoke($0, `copysign`, [value("f32", -0.5), value("f32", 1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:136
+assert_return(() => invoke($0, `copysign`, [value("f32", 0.5), value("f32", -1)]), [value("f32", -0.5)]);
+
+// ./test/core/f32_bitwise.wast:137
+assert_return(() => invoke($0, `copysign`, [value("f32", 0.5), value("f32", 1)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:138
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", -6.2831855)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:139
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", 6.2831855)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:140
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0.5), value("f32", -6.2831855)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:141
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0.5), value("f32", 6.2831855)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:142
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:143
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:144
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:145
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:146
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", -Infinity)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:147
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -0.5), value("f32", Infinity)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:148
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0.5), value("f32", -Infinity)]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:149
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 0.5), value("f32", Infinity)]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:150
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:151
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -0.5),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:152
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:153
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 0.5),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 0.5)],
+);
+
+// ./test/core/f32_bitwise.wast:154
+assert_return(() => invoke($0, `copysign`, [value("f32", -1), value("f32", -0)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:155
+assert_return(() => invoke($0, `copysign`, [value("f32", -1), value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:156
+assert_return(() => invoke($0, `copysign`, [value("f32", 1), value("f32", -0)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:157
+assert_return(() => invoke($0, `copysign`, [value("f32", 1), value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:158
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:159
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:160
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:161
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:162
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:163
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:164
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:165
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:166
+assert_return(() => invoke($0, `copysign`, [value("f32", -1), value("f32", -0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:167
+assert_return(() => invoke($0, `copysign`, [value("f32", -1), value("f32", 0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:168
+assert_return(() => invoke($0, `copysign`, [value("f32", 1), value("f32", -0.5)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:169
+assert_return(() => invoke($0, `copysign`, [value("f32", 1), value("f32", 0.5)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:170
+assert_return(() => invoke($0, `copysign`, [value("f32", -1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:171
+assert_return(() => invoke($0, `copysign`, [value("f32", -1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:172
+assert_return(() => invoke($0, `copysign`, [value("f32", 1), value("f32", -1)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:173
+assert_return(() => invoke($0, `copysign`, [value("f32", 1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:174
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -1), value("f32", -6.2831855)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:175
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -1), value("f32", 6.2831855)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:176
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 1), value("f32", -6.2831855)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:177
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 1), value("f32", 6.2831855)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:178
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:179
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:180
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:181
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:182
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -1), value("f32", -Infinity)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:183
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -1), value("f32", Infinity)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:184
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 1), value("f32", -Infinity)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:185
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 1), value("f32", Infinity)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:186
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:187
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:188
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("f32", -1)],
+);
+
+// ./test/core/f32_bitwise.wast:189
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("f32", 1)],
+);
+
+// ./test/core/f32_bitwise.wast:190
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", -0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:191
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", 0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:192
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", -0)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:193
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", 0)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:194
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:195
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:196
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:197
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:198
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:199
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:200
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:201
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:202
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", -0.5)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:203
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", 0.5)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:204
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", -0.5)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:205
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", 0.5)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:206
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", -1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:207
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", 1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:208
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", -1)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:209
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", 1)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:210
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:211
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:212
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:213
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:214
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:215
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:216
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:217
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:218
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:219
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:220
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:221
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:222
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:223
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:224
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:225
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 6.2831855)],
+);
+
+// ./test/core/f32_bitwise.wast:226
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:227
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:228
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:229
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:230
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:231
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:232
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:233
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:234
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:235
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:236
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:237
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:238
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:239
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:240
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:241
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:242
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:243
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:244
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:245
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:246
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:247
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:248
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:249
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:250
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:251
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:252
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:253
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:254
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:255
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:256
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:257
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:258
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:259
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:260
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:261
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:262
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:263
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:264
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", -0)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:265
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", 0)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:266
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:267
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:268
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:269
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:270
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:271
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:272
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:273
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:274
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:275
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:276
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", -0.5)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:277
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", 0.5)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:278
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:279
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:280
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", -1)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:281
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", 1)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:282
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:283
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:284
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:285
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:286
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:287
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:288
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:289
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:290
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:291
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:292
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:293
+assert_return(
+  () => invoke($0, `copysign`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:294
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:295
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:296
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:297
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f32", Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/f32_bitwise.wast:298
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:299
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:300
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:301
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:302
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:303
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:304
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:305
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:306
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:307
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:308
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:309
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:310
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.5),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:311
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.5),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:312
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.5),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:313
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.5),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:314
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:315
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:316
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:317
+assert_return(
+  () => invoke($0, `copysign`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:318
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:319
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:320
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:321
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:322
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:323
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:324
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:325
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:326
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:327
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", Infinity),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:328
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:329
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", Infinity),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:330
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:331
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:332
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:333
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:334
+assert_return(() => invoke($0, `abs`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:335
+assert_return(() => invoke($0, `abs`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:336
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:337
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:338
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:339
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:340
+assert_return(() => invoke($0, `abs`, [value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:341
+assert_return(() => invoke($0, `abs`, [value("f32", 0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:342
+assert_return(() => invoke($0, `abs`, [value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:343
+assert_return(() => invoke($0, `abs`, [value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:344
+assert_return(() => invoke($0, `abs`, [value("f32", -6.2831855)]), [value("f32", 6.2831855)]);
+
+// ./test/core/f32_bitwise.wast:345
+assert_return(() => invoke($0, `abs`, [value("f32", 6.2831855)]), [value("f32", 6.2831855)]);
+
+// ./test/core/f32_bitwise.wast:346
+assert_return(
+  () => invoke($0, `abs`, [value("f32", -340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:347
+assert_return(
+  () => invoke($0, `abs`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:348
+assert_return(() => invoke($0, `abs`, [value("f32", -Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32_bitwise.wast:349
+assert_return(() => invoke($0, `abs`, [value("f32", Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32_bitwise.wast:350
+assert_return(
+  () => invoke($0, `abs`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:351
+assert_return(
+  () => invoke($0, `abs`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:352
+assert_return(() => invoke($0, `neg`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/f32_bitwise.wast:353
+assert_return(() => invoke($0, `neg`, [value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/f32_bitwise.wast:354
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:355
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/f32_bitwise.wast:356
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:357
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/f32_bitwise.wast:358
+assert_return(() => invoke($0, `neg`, [value("f32", -0.5)]), [value("f32", 0.5)]);
+
+// ./test/core/f32_bitwise.wast:359
+assert_return(() => invoke($0, `neg`, [value("f32", 0.5)]), [value("f32", -0.5)]);
+
+// ./test/core/f32_bitwise.wast:360
+assert_return(() => invoke($0, `neg`, [value("f32", -1)]), [value("f32", 1)]);
+
+// ./test/core/f32_bitwise.wast:361
+assert_return(() => invoke($0, `neg`, [value("f32", 1)]), [value("f32", -1)]);
+
+// ./test/core/f32_bitwise.wast:362
+assert_return(() => invoke($0, `neg`, [value("f32", -6.2831855)]), [value("f32", 6.2831855)]);
+
+// ./test/core/f32_bitwise.wast:363
+assert_return(() => invoke($0, `neg`, [value("f32", 6.2831855)]), [value("f32", -6.2831855)]);
+
+// ./test/core/f32_bitwise.wast:364
+assert_return(
+  () => invoke($0, `neg`, [value("f32", -340282350000000000000000000000000000000)]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:365
+assert_return(
+  () => invoke($0, `neg`, [value("f32", 340282350000000000000000000000000000000)]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/f32_bitwise.wast:366
+assert_return(() => invoke($0, `neg`, [value("f32", -Infinity)]), [value("f32", Infinity)]);
+
+// ./test/core/f32_bitwise.wast:367
+assert_return(() => invoke($0, `neg`, [value("f32", Infinity)]), [value("f32", -Infinity)]);
+
+// ./test/core/f32_bitwise.wast:368
+assert_return(
+  () => invoke($0, `neg`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/f32_bitwise.wast:369
+assert_return(
+  () => invoke($0, `neg`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/f32_bitwise.wast:374
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.copysign (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_bitwise.wast:375
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.abs (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_bitwise.wast:376
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.neg (i64.const 0))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/f32_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/f32_cmp.wast.js
new file mode 100644
index 0000000000..290c82783a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/f32_cmp.wast.js
@@ -0,0 +1,17342 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/f32_cmp.wast
+
+// ./test/core/f32_cmp.wast:4
+let $0 = instantiate(`(module
+  (func (export "eq") (param $$x f32) (param $$y f32) (result i32) (f32.eq (local.get $$x) (local.get $$y)))
+  (func (export "ne") (param $$x f32) (param $$y f32) (result i32) (f32.ne (local.get $$x) (local.get $$y)))
+  (func (export "lt") (param $$x f32) (param $$y f32) (result i32) (f32.lt (local.get $$x) (local.get $$y)))
+  (func (export "le") (param $$x f32) (param $$y f32) (result i32) (f32.le (local.get $$x) (local.get $$y)))
+  (func (export "gt") (param $$x f32) (param $$y f32) (result i32) (f32.gt (local.get $$x) (local.get $$y)))
+  (func (export "ge") (param $$x f32) (param $$y f32) (result i32) (f32.ge (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/f32_cmp.wast:13
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:14
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:15
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:16
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:17
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:18
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:19
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:20
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:21
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:22
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:23
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:24
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:25
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:26
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:27
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:28
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:29
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:30
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:31
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:32
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:33
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:34
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:35
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:36
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:37
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:38
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:39
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:40
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:41
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:42
+assert_return(() => invoke($0, `eq`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:43
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:44
+assert_return(() => invoke($0, `eq`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:45
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:46
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:47
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:48
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:49
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:50
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:51
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:52
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:53
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:54
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:55
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:56
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:57
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:58
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:59
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:60
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:61
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:62
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:63
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:64
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:65
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:66
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:67
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:68
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:69
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:70
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:71
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:72
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:73
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:74
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:75
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:76
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:77
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:78
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:79
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:80
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:81
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:82
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:83
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:84
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:85
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:86
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:87
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:88
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:89
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:90
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:91
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:92
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:93
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:94
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:95
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:96
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:97
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:98
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:99
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:100
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:101
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:102
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:103
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:104
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:105
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:106
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:107
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:108
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:109
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:110
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:111
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:112
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:113
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:114
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:115
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:116
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:117
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:118
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:119
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:120
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:121
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:122
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:123
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:124
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:125
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:126
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:127
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:128
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:129
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:130
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:131
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:132
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:133
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:134
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:135
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:136
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:137
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:138
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:139
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:140
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:141
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:142
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:143
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:144
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:145
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:146
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:147
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:148
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:149
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:150
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:151
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:152
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:153
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:154
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:155
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:156
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:157
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:158
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:159
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:160
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:161
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:162
+assert_return(() => invoke($0, `eq`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:163
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:164
+assert_return(() => invoke($0, `eq`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:165
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:166
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:167
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:168
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:169
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:170
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:171
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:172
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:173
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:174
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:175
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:176
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:177
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:178
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:179
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:180
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:181
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:182
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:183
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:184
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:185
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:186
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:187
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:188
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:189
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:190
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:191
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:192
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:193
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:194
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:195
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:196
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:197
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:198
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:199
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:200
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:201
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:202
+assert_return(() => invoke($0, `eq`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:203
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:204
+assert_return(() => invoke($0, `eq`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:205
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:206
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:207
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:208
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:209
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:210
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:211
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:212
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:213
+assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:214
+assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:215
+assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:216
+assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:217
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:218
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:219
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:220
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:221
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:222
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:223
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:224
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:225
+assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:226
+assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:227
+assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:228
+assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:229
+assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:230
+assert_return(() => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:231
+assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:232
+assert_return(() => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:233
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:234
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:235
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:236
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:237
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:238
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:239
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:240
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:241
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:242
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:243
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:244
+assert_return(
+  () => invoke($0, `eq`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:245
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:246
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:247
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:248
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:249
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:250
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:251
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:252
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:253
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:254
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:255
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:256
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:257
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:258
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:259
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:260
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:261
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:262
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:263
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:264
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:265
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:266
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:267
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:268
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:269
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:270
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:271
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:272
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:273
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:274
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:275
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:276
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:277
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:278
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:279
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:280
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:281
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:282
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:283
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:284
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:285
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:286
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:287
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:288
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:289
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:290
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:291
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:292
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:293
+assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:294
+assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:295
+assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:296
+assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:297
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:298
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:299
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:300
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:301
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:302
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:303
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:304
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:305
+assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:306
+assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:307
+assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:308
+assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:309
+assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:310
+assert_return(() => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:311
+assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:312
+assert_return(() => invoke($0, `eq`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:313
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:314
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:315
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:316
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:317
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:318
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:319
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:320
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:321
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:322
+assert_return(
+  () => invoke($0, `eq`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:323
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:324
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:325
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:326
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:327
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:328
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:329
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:330
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:331
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:332
+assert_return(
+  () => invoke($0, `eq`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:333
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:334
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:335
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:336
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:337
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:338
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:339
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:340
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:341
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:342
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:343
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:344
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:345
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:346
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:347
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:348
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:349
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:350
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:351
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:352
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:353
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:354
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:355
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:356
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:357
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:358
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:359
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:360
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:361
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:362
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:363
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:364
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:365
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:366
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:367
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:368
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:369
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:370
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:371
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:372
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:373
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:374
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:375
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:376
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:377
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:378
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:379
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:380
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:381
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:382
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:383
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:384
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:385
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:386
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:387
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:388
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:389
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:390
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:391
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:392
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:393
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:394
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:395
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:396
+assert_return(
+  () => invoke($0, `eq`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:397
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:398
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:399
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:400
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:401
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:402
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:403
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:404
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:405
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:406
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:407
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:408
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:409
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:410
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:411
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:412
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:413
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:414
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:415
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:416
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:417
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:418
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:419
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:420
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:421
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:422
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:423
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:424
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:425
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:426
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:427
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:428
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:429
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:430
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:431
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:432
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:433
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:434
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:435
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:436
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:437
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:438
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:439
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:440
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:441
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:442
+assert_return(() => invoke($0, `ne`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:443
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:444
+assert_return(() => invoke($0, `ne`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:445
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:446
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:447
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:448
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:449
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:450
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:451
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:452
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:453
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:454
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:455
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:456
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:457
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:458
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:459
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:460
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:461
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:462
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:463
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:464
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:465
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:466
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:467
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:468
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:469
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:470
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:471
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:472
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:473
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:474
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:475
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:476
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:477
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:478
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:479
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:480
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:481
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:482
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:483
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:484
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:485
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:486
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:487
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:488
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:489
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:490
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:491
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:492
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:493
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:494
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:495
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:496
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:497
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:498
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:499
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:500
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:501
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:502
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:503
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:504
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:505
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:506
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:507
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:508
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:509
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:510
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:511
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:512
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:513
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:514
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:515
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:516
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:517
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:518
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:519
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:520
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:521
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:522
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:523
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:524
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:525
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:526
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:527
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:528
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:529
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:530
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:531
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:532
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:533
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:534
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:535
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:536
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:537
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:538
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:539
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:540
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:541
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:542
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:543
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:544
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:545
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:546
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:547
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:548
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:549
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:550
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:551
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:552
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:553
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:554
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:555
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:556
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:557
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:558
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:559
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:560
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:561
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:562
+assert_return(() => invoke($0, `ne`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:563
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:564
+assert_return(() => invoke($0, `ne`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:565
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:566
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:567
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:568
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:569
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:570
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:571
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:572
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:573
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:574
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:575
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:576
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:577
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:578
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:579
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:580
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:581
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:582
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:583
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:584
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:585
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:586
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:587
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:588
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:589
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:590
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:591
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:592
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:593
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:594
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:595
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:596
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:597
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:598
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:599
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:600
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:601
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:602
+assert_return(() => invoke($0, `ne`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:603
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:604
+assert_return(() => invoke($0, `ne`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:605
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:606
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:607
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:608
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:609
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:610
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:611
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:612
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:613
+assert_return(() => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:614
+assert_return(() => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:615
+assert_return(() => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:616
+assert_return(() => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:617
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:618
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:619
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:620
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:621
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:622
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:623
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:624
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:625
+assert_return(() => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:626
+assert_return(() => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:627
+assert_return(() => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:628
+assert_return(() => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:629
+assert_return(() => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:630
+assert_return(() => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:631
+assert_return(() => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:632
+assert_return(() => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:633
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:634
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:635
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:636
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:637
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:638
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:639
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:640
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:641
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:642
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:643
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:644
+assert_return(
+  () => invoke($0, `ne`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:645
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:646
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:647
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:648
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:649
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:650
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:651
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:652
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:653
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:654
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:655
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:656
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:657
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:658
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:659
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:660
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:661
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:662
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:663
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:664
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:665
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:666
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:667
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:668
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:669
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:670
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:671
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:672
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:673
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:674
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:675
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:676
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:677
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:678
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:679
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:680
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:681
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:682
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:683
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:684
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:685
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:686
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:687
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:688
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:689
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:690
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:691
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:692
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:693
+assert_return(() => invoke($0, `ne`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:694
+assert_return(() => invoke($0, `ne`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:695
+assert_return(() => invoke($0, `ne`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:696
+assert_return(() => invoke($0, `ne`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:697
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:698
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:699
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:700
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:701
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:702
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:703
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:704
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:705
+assert_return(() => invoke($0, `ne`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:706
+assert_return(() => invoke($0, `ne`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:707
+assert_return(() => invoke($0, `ne`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:708
+assert_return(() => invoke($0, `ne`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:709
+assert_return(() => invoke($0, `ne`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:710
+assert_return(() => invoke($0, `ne`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:711
+assert_return(() => invoke($0, `ne`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:712
+assert_return(() => invoke($0, `ne`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:713
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:714
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:715
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:716
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:717
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:718
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:719
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:720
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:721
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:722
+assert_return(
+  () => invoke($0, `ne`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:723
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:724
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:725
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:726
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:727
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:728
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:729
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:730
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:731
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:732
+assert_return(
+  () => invoke($0, `ne`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:733
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:734
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:735
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:736
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:737
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:738
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:739
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:740
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:741
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:742
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:743
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:744
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:745
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:746
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:747
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:748
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:749
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:750
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:751
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:752
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:753
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:754
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:755
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:756
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:757
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:758
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:759
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:760
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:761
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:762
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:763
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:764
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:765
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:766
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:767
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:768
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:769
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:770
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:771
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:772
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:773
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:774
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:775
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:776
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:777
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:778
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:779
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:780
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:781
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:782
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:783
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:784
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:785
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:786
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:787
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:788
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:789
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:790
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:791
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:792
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:793
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:794
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:795
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:796
+assert_return(
+  () => invoke($0, `ne`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:797
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:798
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:799
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:800
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:801
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:802
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:803
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:804
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:805
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:806
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:807
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:808
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:809
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:810
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:811
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:812
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:813
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:814
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:815
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:816
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:817
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:818
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:819
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:820
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:821
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:822
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:823
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:824
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:825
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:826
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:827
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:828
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:829
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:830
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:831
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:832
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:833
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:834
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:835
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:836
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:837
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:838
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:839
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:840
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:841
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:842
+assert_return(() => invoke($0, `lt`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:843
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:844
+assert_return(() => invoke($0, `lt`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:845
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:846
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:847
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:848
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:849
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:850
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:851
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:852
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:853
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:854
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:855
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:856
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:857
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:858
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:859
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:860
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:861
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:862
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:863
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:864
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:865
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:866
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:867
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:868
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:869
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:870
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:871
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:872
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:873
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:874
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:875
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:876
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:877
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:878
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:879
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:880
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:881
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:882
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:883
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:884
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:885
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:886
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:887
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:888
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:889
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:890
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:891
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:892
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:893
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:894
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:895
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:896
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:897
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:898
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:899
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:900
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:901
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:902
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:903
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:904
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:905
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:906
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:907
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:908
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:909
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:910
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:911
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:912
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:913
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:914
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:915
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:916
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:917
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:918
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:919
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:920
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:921
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:922
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:923
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:924
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:925
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:926
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:927
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:928
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:929
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:930
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:931
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:932
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:933
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:934
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:935
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:936
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:937
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:938
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:939
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:940
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:941
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:942
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:943
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:944
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:945
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:946
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:947
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:948
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:949
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:950
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:951
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:952
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:953
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:954
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:955
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:956
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:957
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:958
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:959
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:960
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:961
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:962
+assert_return(() => invoke($0, `lt`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:963
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:964
+assert_return(() => invoke($0, `lt`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:965
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:966
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:967
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:968
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:969
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:970
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:971
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:972
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:973
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:974
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:975
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:976
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:977
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:978
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:979
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:980
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:981
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:982
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:983
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:984
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:985
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:986
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:987
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:988
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:989
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:990
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:991
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:992
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:993
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:994
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:995
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:996
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:997
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:998
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:999
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1000
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1001
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1002
+assert_return(() => invoke($0, `lt`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1003
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1004
+assert_return(() => invoke($0, `lt`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1005
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1006
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1007
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1008
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1009
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1010
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1011
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1012
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1013
+assert_return(() => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1014
+assert_return(() => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1015
+assert_return(() => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1016
+assert_return(() => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1017
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1018
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1019
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1020
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1021
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1022
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1023
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1024
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1025
+assert_return(() => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1026
+assert_return(() => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1027
+assert_return(() => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1028
+assert_return(() => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1029
+assert_return(() => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1030
+assert_return(() => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1031
+assert_return(() => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1032
+assert_return(() => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1033
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1034
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1035
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1036
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1037
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1038
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1039
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1040
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1041
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1042
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1043
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1044
+assert_return(
+  () => invoke($0, `lt`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1045
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1046
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1047
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1048
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1049
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1050
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1051
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1052
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1053
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1054
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1055
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1056
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1057
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1058
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1059
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1060
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1061
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1062
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1063
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1064
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1065
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1066
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1067
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1068
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1069
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1070
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1071
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1072
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1073
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1074
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1075
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1076
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1077
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1078
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1079
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1080
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1081
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1082
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1083
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1084
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1085
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1086
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1087
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1088
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1089
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1090
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1091
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1092
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1093
+assert_return(() => invoke($0, `lt`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1094
+assert_return(() => invoke($0, `lt`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1095
+assert_return(() => invoke($0, `lt`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1096
+assert_return(() => invoke($0, `lt`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1097
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1098
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1099
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1100
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1101
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1102
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1103
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1104
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1105
+assert_return(() => invoke($0, `lt`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1106
+assert_return(() => invoke($0, `lt`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1107
+assert_return(() => invoke($0, `lt`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1108
+assert_return(() => invoke($0, `lt`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1109
+assert_return(() => invoke($0, `lt`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1110
+assert_return(() => invoke($0, `lt`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1111
+assert_return(() => invoke($0, `lt`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1112
+assert_return(() => invoke($0, `lt`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1113
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1114
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1115
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1116
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1117
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1118
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1119
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1120
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1121
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1122
+assert_return(
+  () => invoke($0, `lt`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1123
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1124
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1125
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1126
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1127
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1128
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1129
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1130
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1131
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1132
+assert_return(
+  () => invoke($0, `lt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1133
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1134
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1135
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1136
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1137
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1138
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1139
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1140
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1141
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1142
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1143
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1144
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1145
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1146
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1147
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1148
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1149
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1150
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1151
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1152
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1153
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1154
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1155
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1156
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1157
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1158
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1159
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1160
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1161
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1162
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1163
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1164
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1165
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1166
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1167
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1168
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1169
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1170
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1171
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1172
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1173
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1174
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1175
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1176
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1177
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1178
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1179
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1180
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1181
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1182
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1183
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1184
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1185
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1186
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1187
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1188
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1189
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1190
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1191
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1192
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1193
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1194
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1195
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1196
+assert_return(
+  () => invoke($0, `lt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1197
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1198
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1199
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1200
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1201
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1202
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1203
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1204
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1205
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1206
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1207
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1208
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1209
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1210
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1211
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1212
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1213
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1214
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1215
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1216
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1217
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1218
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1219
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1220
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1221
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1222
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1223
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1224
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1225
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1226
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1227
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1228
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1229
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1230
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1231
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1232
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1233
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1234
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1235
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1236
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1237
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1238
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1239
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1240
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1241
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1242
+assert_return(() => invoke($0, `le`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1243
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1244
+assert_return(() => invoke($0, `le`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1245
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1246
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1247
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1248
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1249
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1250
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1251
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1252
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1253
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1254
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1255
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1256
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1257
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1258
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1259
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1260
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1261
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1262
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1263
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1264
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1265
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1266
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1267
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1268
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1269
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1270
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1271
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1272
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1273
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1274
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1275
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1276
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1277
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1278
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1279
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1280
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1281
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1282
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1283
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1284
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1285
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1286
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1287
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1288
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1289
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1290
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1291
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1292
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1293
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1294
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1295
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1296
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1297
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1298
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1299
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1300
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1301
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1302
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1303
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1304
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1305
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1306
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1307
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1308
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1309
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1310
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1311
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1312
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1313
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1314
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1315
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1316
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1317
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1318
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1319
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1320
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1321
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1322
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1323
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1324
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1325
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1326
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1327
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1328
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1329
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1330
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1331
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1332
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1333
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1334
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1335
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1336
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1337
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1338
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1339
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1340
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1341
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1342
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1343
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1344
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1345
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1346
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1347
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1348
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1349
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1350
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1351
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1352
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1353
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1354
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1355
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1356
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1357
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1358
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1359
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1360
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1361
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1362
+assert_return(() => invoke($0, `le`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1363
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1364
+assert_return(() => invoke($0, `le`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1365
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1366
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1367
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1368
+assert_return(
+  () => invoke($0, `le`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1369
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1370
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1371
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1372
+assert_return(
+  () => invoke($0, `le`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1373
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1374
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1375
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1376
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1377
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1378
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1379
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1380
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1381
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1382
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1383
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1384
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1385
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1386
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1387
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1388
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1389
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1390
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1391
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1392
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1393
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1394
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1395
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1396
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1397
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1398
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1399
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1400
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1401
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1402
+assert_return(() => invoke($0, `le`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1403
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1404
+assert_return(() => invoke($0, `le`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1405
+assert_return(
+  () => invoke($0, `le`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1406
+assert_return(
+  () => invoke($0, `le`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1407
+assert_return(
+  () => invoke($0, `le`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1408
+assert_return(
+  () => invoke($0, `le`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1409
+assert_return(
+  () => invoke($0, `le`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1410
+assert_return(
+  () => invoke($0, `le`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1411
+assert_return(
+  () => invoke($0, `le`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1412
+assert_return(
+  () => invoke($0, `le`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1413
+assert_return(() => invoke($0, `le`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1414
+assert_return(() => invoke($0, `le`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1415
+assert_return(() => invoke($0, `le`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1416
+assert_return(() => invoke($0, `le`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1417
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1418
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1419
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1420
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1421
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1422
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1423
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1424
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1425
+assert_return(() => invoke($0, `le`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1426
+assert_return(() => invoke($0, `le`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1427
+assert_return(() => invoke($0, `le`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1428
+assert_return(() => invoke($0, `le`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1429
+assert_return(() => invoke($0, `le`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1430
+assert_return(() => invoke($0, `le`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1431
+assert_return(() => invoke($0, `le`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1432
+assert_return(() => invoke($0, `le`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1433
+assert_return(
+  () => invoke($0, `le`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1434
+assert_return(
+  () => invoke($0, `le`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1435
+assert_return(
+  () => invoke($0, `le`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1436
+assert_return(
+  () => invoke($0, `le`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1437
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1438
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1439
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1440
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1441
+assert_return(
+  () => invoke($0, `le`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1442
+assert_return(
+  () => invoke($0, `le`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1443
+assert_return(
+  () => invoke($0, `le`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1444
+assert_return(
+  () => invoke($0, `le`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1445
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1446
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1447
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1448
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1449
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1450
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1451
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1452
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1453
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1454
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1455
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1456
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1457
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1458
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1459
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1460
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1461
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1462
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1463
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1464
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1465
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1466
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1467
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1468
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1469
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1470
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1471
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1472
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1473
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1474
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1475
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1476
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1477
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1478
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1479
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1480
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1481
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1482
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1483
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1484
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1485
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1486
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1487
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1488
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1489
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1490
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1491
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1492
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1493
+assert_return(() => invoke($0, `le`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1494
+assert_return(() => invoke($0, `le`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1495
+assert_return(() => invoke($0, `le`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1496
+assert_return(() => invoke($0, `le`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1497
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1498
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1499
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1500
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1501
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1502
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1503
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1504
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1505
+assert_return(() => invoke($0, `le`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1506
+assert_return(() => invoke($0, `le`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1507
+assert_return(() => invoke($0, `le`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1508
+assert_return(() => invoke($0, `le`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1509
+assert_return(() => invoke($0, `le`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1510
+assert_return(() => invoke($0, `le`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1511
+assert_return(() => invoke($0, `le`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1512
+assert_return(() => invoke($0, `le`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1513
+assert_return(
+  () => invoke($0, `le`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1514
+assert_return(
+  () => invoke($0, `le`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1515
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1516
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1517
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1518
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1519
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1520
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1521
+assert_return(
+  () => invoke($0, `le`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1522
+assert_return(
+  () => invoke($0, `le`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1523
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1524
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1525
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1526
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1527
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1528
+assert_return(
+  () => invoke($0, `le`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1529
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1530
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1531
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1532
+assert_return(
+  () => invoke($0, `le`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1533
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1534
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1535
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1536
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1537
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1538
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1539
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1540
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1541
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1542
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1543
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1544
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1545
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1546
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1547
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1548
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1549
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1550
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1551
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1552
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1553
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1554
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1555
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1556
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1557
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1558
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1559
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1560
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1561
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1562
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1563
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1564
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1565
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1566
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1567
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1568
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1569
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1570
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1571
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1572
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1573
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1574
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1575
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1576
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1577
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1578
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1579
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1580
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1581
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1582
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1583
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1584
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1585
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1586
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1587
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1588
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1589
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1590
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1591
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1592
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1593
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1594
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1595
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1596
+assert_return(
+  () => invoke($0, `le`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1597
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1598
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1599
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1600
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1601
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1602
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1603
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1604
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1605
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1606
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1607
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1608
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1609
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1610
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1611
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1612
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1613
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1614
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1615
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1616
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1617
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1618
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1619
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1620
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1621
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1622
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1623
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1624
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1625
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1626
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1627
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1628
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1629
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1630
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1631
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1632
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1633
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1634
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1635
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1636
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1637
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1638
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1639
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1640
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1641
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1642
+assert_return(() => invoke($0, `gt`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1643
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1644
+assert_return(() => invoke($0, `gt`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1645
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1646
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1647
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1648
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1649
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1650
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1651
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1652
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1653
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1654
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1655
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1656
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1657
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1658
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1659
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1660
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1661
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1662
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1663
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1664
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1665
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1666
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1667
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1668
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1669
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1670
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1671
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1672
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1673
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1674
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1675
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1676
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1677
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1678
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1679
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1680
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1681
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1682
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1683
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1684
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1685
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1686
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1687
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1688
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1689
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1690
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1691
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1692
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1693
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1694
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1695
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1696
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1697
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1698
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1699
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1700
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1701
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1702
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1703
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1704
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1705
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1706
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1707
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1708
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1709
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1710
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1711
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1712
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1713
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1714
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1715
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1716
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1717
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1718
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1719
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1720
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1721
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1722
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1723
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1724
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1725
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1726
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1727
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1728
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1729
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1730
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1731
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1732
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1733
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1734
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1735
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1736
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1737
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1738
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1739
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1740
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1741
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1742
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1743
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1744
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1745
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1746
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1747
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1748
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1749
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1750
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1751
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1752
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1753
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1754
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1755
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1756
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1757
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1758
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1759
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1760
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1761
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1762
+assert_return(() => invoke($0, `gt`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1763
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1764
+assert_return(() => invoke($0, `gt`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1765
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1766
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1767
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1768
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1769
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1770
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1771
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1772
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1773
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1774
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1775
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1776
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1777
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1778
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1779
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1780
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1781
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1782
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1783
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1784
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1785
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1786
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1787
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1788
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1789
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1790
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1791
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1792
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1793
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1794
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1795
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1796
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1797
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1798
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1799
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1800
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1801
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1802
+assert_return(() => invoke($0, `gt`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1803
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1804
+assert_return(() => invoke($0, `gt`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1805
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1806
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1807
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1808
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1809
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1810
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1811
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1812
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1813
+assert_return(() => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1814
+assert_return(() => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1815
+assert_return(() => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1816
+assert_return(() => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1817
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1818
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1819
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1820
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1821
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1822
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1823
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1824
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1825
+assert_return(() => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1826
+assert_return(() => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1827
+assert_return(() => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1828
+assert_return(() => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1829
+assert_return(() => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1830
+assert_return(() => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1831
+assert_return(() => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1832
+assert_return(() => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1833
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1834
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1835
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1836
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1837
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1838
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1839
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1840
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1841
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1842
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1843
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1844
+assert_return(
+  () => invoke($0, `gt`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1845
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1846
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1847
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1848
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1849
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1850
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1851
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1852
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1853
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1854
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1855
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1856
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1857
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1858
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1859
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1860
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1861
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1862
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1863
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1864
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1865
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1866
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1867
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1868
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1869
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1870
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1871
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1872
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1873
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1874
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1875
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1876
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1877
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1878
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1879
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1880
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1881
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1882
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1883
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1884
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1885
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1886
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1887
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1888
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1889
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1890
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1891
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1892
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1893
+assert_return(() => invoke($0, `gt`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1894
+assert_return(() => invoke($0, `gt`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1895
+assert_return(() => invoke($0, `gt`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1896
+assert_return(() => invoke($0, `gt`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1897
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1898
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1899
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1900
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1901
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1902
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1903
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1904
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1905
+assert_return(() => invoke($0, `gt`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1906
+assert_return(() => invoke($0, `gt`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1907
+assert_return(() => invoke($0, `gt`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1908
+assert_return(() => invoke($0, `gt`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1909
+assert_return(() => invoke($0, `gt`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1910
+assert_return(() => invoke($0, `gt`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:1911
+assert_return(() => invoke($0, `gt`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1912
+assert_return(() => invoke($0, `gt`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:1913
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1914
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1915
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1916
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1917
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1918
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1919
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1920
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1921
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1922
+assert_return(
+  () => invoke($0, `gt`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1923
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:1924
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1925
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1926
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1927
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1928
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1929
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1930
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1931
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1932
+assert_return(
+  () => invoke($0, `gt`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1933
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1934
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1935
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1936
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1937
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1938
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1939
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1940
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1941
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1942
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1943
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1944
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1945
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1946
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1947
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1948
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1949
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1950
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1951
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1952
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1953
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1954
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1955
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1956
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1957
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1958
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1959
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1960
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1961
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1962
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1963
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1964
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1965
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1966
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1967
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1968
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1969
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1970
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1971
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1972
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1973
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1974
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1975
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1976
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1977
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1978
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1979
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1980
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1981
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1982
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1983
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1984
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1985
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1986
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1987
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1988
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1989
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1990
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1991
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1992
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1993
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1994
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1995
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1996
+assert_return(
+  () => invoke($0, `gt`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1997
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1998
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:1999
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2000
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2001
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2002
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2003
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2004
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2005
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2006
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2007
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2008
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2009
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2010
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2011
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2012
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2013
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2014
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2015
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2016
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2017
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2018
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2019
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2020
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2021
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2022
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2023
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2024
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2025
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2026
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2027
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2028
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2029
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2030
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2031
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2032
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2033
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2034
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2035
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2036
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2037
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2038
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2039
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2040
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2041
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2042
+assert_return(() => invoke($0, `ge`, [value("f32", -0), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2043
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2044
+assert_return(() => invoke($0, `ge`, [value("f32", 0), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2045
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2046
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2047
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2048
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2049
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2050
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2051
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2052
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2053
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2054
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2055
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2056
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2057
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2058
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2059
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2060
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2061
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2062
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2063
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2064
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2065
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2066
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2067
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2068
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2069
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2070
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2071
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2072
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2073
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2074
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2075
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2076
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2077
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2078
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2079
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2080
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2081
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2082
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2083
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2084
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2085
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2086
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2087
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2088
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2089
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2090
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2091
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2092
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2093
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2094
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2095
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2096
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2097
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2098
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2099
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2100
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2101
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2102
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2103
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2104
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2105
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2106
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2107
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2108
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2109
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2110
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2111
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2112
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2113
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2114
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2115
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2116
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2117
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2118
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2119
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2120
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2121
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2122
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2123
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2124
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2125
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2126
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2127
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2128
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2129
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2130
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2131
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2132
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2133
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2134
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2135
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2136
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2137
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2138
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2139
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2140
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2141
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2142
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2143
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.5),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2144
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.5),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2145
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2146
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2147
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2148
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2149
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2150
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2151
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2152
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2153
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2154
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2155
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2156
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2157
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2158
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2159
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.5),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2160
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 0.5),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2161
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2162
+assert_return(() => invoke($0, `ge`, [value("f32", -0.5), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2163
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2164
+assert_return(() => invoke($0, `ge`, [value("f32", 0.5), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2165
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2166
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2167
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2168
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2169
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2170
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2171
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2172
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 0.5), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2173
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2174
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2175
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2176
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2177
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2178
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2179
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2180
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2181
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2182
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2183
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 1),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2184
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2185
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2186
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2187
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2188
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2189
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2190
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2191
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2192
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2193
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2194
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2195
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", -6.2831855)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2196
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", 6.2831855)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2197
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2198
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2199
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 1),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2200
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 1),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2201
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2202
+assert_return(() => invoke($0, `ge`, [value("f32", -1), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2203
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2204
+assert_return(() => invoke($0, `ge`, [value("f32", 1), value("f32", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2205
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2206
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2207
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2208
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2209
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2210
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2211
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2212
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 1), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2213
+assert_return(() => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2214
+assert_return(() => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2215
+assert_return(() => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2216
+assert_return(() => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2217
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2218
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2219
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2220
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2221
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2222
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2223
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2224
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2225
+assert_return(() => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2226
+assert_return(() => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2227
+assert_return(() => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2228
+assert_return(() => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2229
+assert_return(() => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2230
+assert_return(() => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2231
+assert_return(() => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2232
+assert_return(() => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2233
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2234
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2235
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2236
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2237
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2238
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2239
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2240
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2241
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2242
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -6.2831855), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2243
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2244
+assert_return(
+  () => invoke($0, `ge`, [value("f32", 6.2831855), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2245
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2246
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2247
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2248
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2249
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2250
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2251
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2252
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 6.2831855),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2253
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2254
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2255
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2256
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2257
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2258
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2259
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2260
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2261
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2262
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2263
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2264
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2265
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2266
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2267
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2268
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2269
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2270
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2271
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2272
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2273
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2274
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2275
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2276
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2277
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2278
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2279
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2280
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2281
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2282
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2283
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2284
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2285
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2286
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2287
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2288
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2289
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2290
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2291
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2292
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", 340282350000000000000000000000000000000),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2293
+assert_return(() => invoke($0, `ge`, [value("f32", -Infinity), value("f32", -0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2294
+assert_return(() => invoke($0, `ge`, [value("f32", -Infinity), value("f32", 0)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2295
+assert_return(() => invoke($0, `ge`, [value("f32", Infinity), value("f32", -0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2296
+assert_return(() => invoke($0, `ge`, [value("f32", Infinity), value("f32", 0)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2297
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2298
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2299
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2300
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2301
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2302
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2303
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", Infinity),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2304
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", Infinity),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2305
+assert_return(() => invoke($0, `ge`, [value("f32", -Infinity), value("f32", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2306
+assert_return(() => invoke($0, `ge`, [value("f32", -Infinity), value("f32", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2307
+assert_return(() => invoke($0, `ge`, [value("f32", Infinity), value("f32", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2308
+assert_return(() => invoke($0, `ge`, [value("f32", Infinity), value("f32", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2309
+assert_return(() => invoke($0, `ge`, [value("f32", -Infinity), value("f32", -1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2310
+assert_return(() => invoke($0, `ge`, [value("f32", -Infinity), value("f32", 1)]), [value("i32", 0)]);
+
+// ./test/core/f32_cmp.wast:2311
+assert_return(() => invoke($0, `ge`, [value("f32", Infinity), value("f32", -1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2312
+assert_return(() => invoke($0, `ge`, [value("f32", Infinity), value("f32", 1)]), [value("i32", 1)]);
+
+// ./test/core/f32_cmp.wast:2313
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -Infinity), value("f32", -6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2314
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -Infinity), value("f32", 6.2831855)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2315
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), value("f32", -6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2316
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), value("f32", 6.2831855)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2317
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2318
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2319
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", Infinity),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2320
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", Infinity),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2321
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -Infinity), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2322
+assert_return(
+  () => invoke($0, `ge`, [value("f32", -Infinity), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2323
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), value("f32", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2324
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), value("f32", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f32_cmp.wast:2325
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2326
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2327
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2328
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f32", -Infinity),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2329
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2330
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0xff])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2331
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2332
+assert_return(
+  () => invoke($0, `ge`, [value("f32", Infinity), bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2333
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2334
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2335
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2336
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2337
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2338
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2339
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2340
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2341
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2342
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2343
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2344
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2345
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2346
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2347
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2348
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2349
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2350
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2351
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2352
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2353
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2354
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2355
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2356
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2357
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2358
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2359
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2360
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2361
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2362
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2363
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2364
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2365
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2366
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2367
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2368
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2369
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2370
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2371
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2372
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2373
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2374
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2375
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2376
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2377
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2378
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2379
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2380
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 6.2831855),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2381
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2382
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2383
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2384
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2385
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2386
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2387
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2388
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2389
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2390
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2391
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2392
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0xff]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2393
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2394
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    value("f32", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2395
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2396
+assert_return(
+  () => invoke($0, `ge`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f]), value("f32", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2397
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2398
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2399
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2400
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2401
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2402
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2403
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2404
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2405
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2406
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2407
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2408
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2409
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2410
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2411
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2412
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f32_cmp.wast:2417
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.eq (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_cmp.wast:2418
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.ge (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_cmp.wast:2419
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.gt (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_cmp.wast:2420
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.le (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_cmp.wast:2421
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.lt (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f32_cmp.wast:2422
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32.ne (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/f64.wast.js b/js/src/jit-test/tests/wasm/spec/spec/f64.wast.js
new file mode 100644
index 0000000000..6bce2a366e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/f64.wast.js
@@ -0,0 +1,20658 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/f64.wast
+
+// ./test/core/f64.wast:5
+let $0 = instantiate(`(module
+  (func (export "add") (param $$x f64) (param $$y f64) (result f64) (f64.add (local.get $$x) (local.get $$y)))
+  (func (export "sub") (param $$x f64) (param $$y f64) (result f64) (f64.sub (local.get $$x) (local.get $$y)))
+  (func (export "mul") (param $$x f64) (param $$y f64) (result f64) (f64.mul (local.get $$x) (local.get $$y)))
+  (func (export "div") (param $$x f64) (param $$y f64) (result f64) (f64.div (local.get $$x) (local.get $$y)))
+  (func (export "sqrt") (param $$x f64) (result f64) (f64.sqrt (local.get $$x)))
+  (func (export "min") (param $$x f64) (param $$y f64) (result f64) (f64.min (local.get $$x) (local.get $$y)))
+  (func (export "max") (param $$x f64) (param $$y f64) (result f64) (f64.max (local.get $$x) (local.get $$y)))
+  (func (export "ceil") (param $$x f64) (result f64) (f64.ceil (local.get $$x)))
+  (func (export "floor") (param $$x f64) (result f64) (f64.floor (local.get $$x)))
+  (func (export "trunc") (param $$x f64) (result f64) (f64.trunc (local.get $$x)))
+  (func (export "nearest") (param $$x f64) (result f64) (f64.nearest (local.get $$x)))
+)`);
+
+// ./test/core/f64.wast:19
+assert_return(() => invoke($0, `add`, [value("f64", -0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:20
+assert_return(() => invoke($0, `add`, [value("f64", -0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:21
+assert_return(() => invoke($0, `add`, [value("f64", 0), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:22
+assert_return(() => invoke($0, `add`, [value("f64", 0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:23
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:24
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:25
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:26
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:27
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:28
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:29
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:30
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:31
+assert_return(() => invoke($0, `add`, [value("f64", -0), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:32
+assert_return(() => invoke($0, `add`, [value("f64", -0), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:33
+assert_return(() => invoke($0, `add`, [value("f64", 0), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:34
+assert_return(() => invoke($0, `add`, [value("f64", 0), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:35
+assert_return(() => invoke($0, `add`, [value("f64", -0), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:36
+assert_return(() => invoke($0, `add`, [value("f64", -0), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:37
+assert_return(() => invoke($0, `add`, [value("f64", 0), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:38
+assert_return(() => invoke($0, `add`, [value("f64", 0), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:39
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:40
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:41
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:42
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:43
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:44
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:45
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:46
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:47
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:48
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:49
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:50
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:51
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:52
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:53
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:54
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:55
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:56
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:57
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:58
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:59
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:60
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:61
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:62
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:63
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:64
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:65
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:66
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:67
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:68
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:69
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:70
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:71
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:72
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:73
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:74
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:75
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:76
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:77
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:78
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:79
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:80
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:81
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:82
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:83
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:84
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:85
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:86
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:87
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:88
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:89
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:90
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:91
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:92
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:93
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:94
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:95
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:96
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:97
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:98
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:99
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:100
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:101
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:102
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:103
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:104
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:105
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:106
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:107
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:108
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:109
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:110
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:111
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:112
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:113
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:114
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:115
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:116
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:117
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:118
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:119
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:120
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:121
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:122
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:123
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:124
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:125
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:126
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:127
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:128
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:129
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:130
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:131
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:132
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:133
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:134
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:135
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:136
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:137
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:138
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:139
+assert_return(() => invoke($0, `add`, [value("f64", -0.5), value("f64", -0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:140
+assert_return(() => invoke($0, `add`, [value("f64", -0.5), value("f64", 0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:141
+assert_return(() => invoke($0, `add`, [value("f64", 0.5), value("f64", -0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:142
+assert_return(() => invoke($0, `add`, [value("f64", 0.5), value("f64", 0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:143
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:144
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:145
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:146
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:147
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:148
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:149
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:150
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:151
+assert_return(() => invoke($0, `add`, [value("f64", -0.5), value("f64", -0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:152
+assert_return(() => invoke($0, `add`, [value("f64", -0.5), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:153
+assert_return(() => invoke($0, `add`, [value("f64", 0.5), value("f64", -0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:154
+assert_return(() => invoke($0, `add`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:155
+assert_return(() => invoke($0, `add`, [value("f64", -0.5), value("f64", -1)]), [value("f64", -1.5)]);
+
+// ./test/core/f64.wast:156
+assert_return(() => invoke($0, `add`, [value("f64", -0.5), value("f64", 1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:157
+assert_return(() => invoke($0, `add`, [value("f64", 0.5), value("f64", -1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:158
+assert_return(() => invoke($0, `add`, [value("f64", 0.5), value("f64", 1)]), [value("f64", 1.5)]);
+
+// ./test/core/f64.wast:159
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -6.783185307179586)],
+);
+
+// ./test/core/f64.wast:160
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 5.783185307179586)],
+);
+
+// ./test/core/f64.wast:161
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -5.783185307179586)],
+);
+
+// ./test/core/f64.wast:162
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 6.783185307179586)],
+);
+
+// ./test/core/f64.wast:163
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:164
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:165
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:166
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:167
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0.5), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:168
+assert_return(
+  () => invoke($0, `add`, [value("f64", -0.5), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:169
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0.5), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:170
+assert_return(
+  () => invoke($0, `add`, [value("f64", 0.5), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:171
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:172
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:173
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:174
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:175
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:176
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:177
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:178
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:179
+assert_return(() => invoke($0, `add`, [value("f64", -1), value("f64", -0)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:180
+assert_return(() => invoke($0, `add`, [value("f64", -1), value("f64", 0)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:181
+assert_return(() => invoke($0, `add`, [value("f64", 1), value("f64", -0)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:182
+assert_return(() => invoke($0, `add`, [value("f64", 1), value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:183
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:184
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:185
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:186
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:187
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:188
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:189
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:190
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:191
+assert_return(() => invoke($0, `add`, [value("f64", -1), value("f64", -0.5)]), [value("f64", -1.5)]);
+
+// ./test/core/f64.wast:192
+assert_return(() => invoke($0, `add`, [value("f64", -1), value("f64", 0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:193
+assert_return(() => invoke($0, `add`, [value("f64", 1), value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:194
+assert_return(() => invoke($0, `add`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 1.5)]);
+
+// ./test/core/f64.wast:195
+assert_return(() => invoke($0, `add`, [value("f64", -1), value("f64", -1)]), [value("f64", -2)]);
+
+// ./test/core/f64.wast:196
+assert_return(() => invoke($0, `add`, [value("f64", -1), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:197
+assert_return(() => invoke($0, `add`, [value("f64", 1), value("f64", -1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:198
+assert_return(() => invoke($0, `add`, [value("f64", 1), value("f64", 1)]), [value("f64", 2)]);
+
+// ./test/core/f64.wast:199
+assert_return(
+  () => invoke($0, `add`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", -7.283185307179586)],
+);
+
+// ./test/core/f64.wast:200
+assert_return(
+  () => invoke($0, `add`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", 5.283185307179586)],
+);
+
+// ./test/core/f64.wast:201
+assert_return(
+  () => invoke($0, `add`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", -5.283185307179586)],
+);
+
+// ./test/core/f64.wast:202
+assert_return(
+  () => invoke($0, `add`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", 7.283185307179586)],
+);
+
+// ./test/core/f64.wast:203
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:204
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:205
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:206
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:207
+assert_return(
+  () => invoke($0, `add`, [value("f64", -1), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:208
+assert_return(
+  () => invoke($0, `add`, [value("f64", -1), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:209
+assert_return(
+  () => invoke($0, `add`, [value("f64", 1), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:210
+assert_return(
+  () => invoke($0, `add`, [value("f64", 1), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:211
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:212
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:213
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:214
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:215
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:216
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:217
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:218
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:219
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:220
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:221
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:222
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:223
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:224
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:225
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:226
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:227
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:228
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:229
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:230
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:231
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -6.783185307179586)],
+);
+
+// ./test/core/f64.wast:232
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", -5.783185307179586)],
+);
+
+// ./test/core/f64.wast:233
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", 5.783185307179586)],
+);
+
+// ./test/core/f64.wast:234
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 6.783185307179586)],
+);
+
+// ./test/core/f64.wast:235
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", -7.283185307179586)],
+);
+
+// ./test/core/f64.wast:236
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", -5.283185307179586)],
+);
+
+// ./test/core/f64.wast:237
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", 5.283185307179586)],
+);
+
+// ./test/core/f64.wast:238
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 7.283185307179586)],
+);
+
+// ./test/core/f64.wast:239
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -12.566370614359172)],
+);
+
+// ./test/core/f64.wast:240
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:241
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:242
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 12.566370614359172)],
+);
+
+// ./test/core/f64.wast:243
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:244
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:245
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:246
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:247
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:248
+assert_return(
+  () => invoke($0, `add`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:249
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:250
+assert_return(
+  () => invoke($0, `add`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:251
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:252
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:253
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:254
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:255
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:256
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:257
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:258
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:259
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:260
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:261
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:262
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:263
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:264
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:265
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:266
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:267
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:268
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:269
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:270
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:271
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:272
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:273
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:274
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:275
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:276
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:277
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:278
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:279
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:280
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:281
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:282
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:283
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:284
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:285
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:286
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:287
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:288
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:289
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:290
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:291
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:292
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:293
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:294
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:295
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:296
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:297
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:298
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:299
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:300
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", 0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:301
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", -0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:302
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:303
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:304
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:305
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:306
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:307
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:308
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:309
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:310
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:311
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:312
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:313
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:314
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:315
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:316
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", 1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:317
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", -1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:318
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:319
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:320
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:321
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:322
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:323
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:324
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:325
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:326
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:327
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:328
+assert_return(
+  () => invoke($0, `add`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:329
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:330
+assert_return(
+  () => invoke($0, `add`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:331
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:332
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:333
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:334
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:335
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:336
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:337
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:338
+assert_return(
+  () => invoke($0, `add`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:339
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:340
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:341
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:342
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:343
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:344
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:345
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:346
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:347
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:348
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:349
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:350
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:351
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:352
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:353
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:354
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:355
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:356
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:357
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:358
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:359
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:360
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:361
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:362
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:363
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:364
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:365
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:366
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:367
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:368
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:369
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:370
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:371
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:372
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:373
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:374
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:375
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:376
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:377
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:378
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:379
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:380
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:381
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:382
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:383
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:384
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:385
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:386
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:387
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:388
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:389
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:390
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:391
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:392
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:393
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:394
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:395
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:396
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:397
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:398
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:399
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:400
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:401
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:402
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:403
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:404
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:405
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:406
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:407
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:408
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:409
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:410
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:411
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:412
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:413
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:414
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:415
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:416
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:417
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:418
+assert_return(
+  () => invoke($0, `add`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:419
+assert_return(() => invoke($0, `sub`, [value("f64", -0), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:420
+assert_return(() => invoke($0, `sub`, [value("f64", -0), value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:421
+assert_return(() => invoke($0, `sub`, [value("f64", 0), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:422
+assert_return(() => invoke($0, `sub`, [value("f64", 0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:423
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:424
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:425
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:426
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:427
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:428
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:429
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:430
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:431
+assert_return(() => invoke($0, `sub`, [value("f64", -0), value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:432
+assert_return(() => invoke($0, `sub`, [value("f64", -0), value("f64", 0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:433
+assert_return(() => invoke($0, `sub`, [value("f64", 0), value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:434
+assert_return(() => invoke($0, `sub`, [value("f64", 0), value("f64", 0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:435
+assert_return(() => invoke($0, `sub`, [value("f64", -0), value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:436
+assert_return(() => invoke($0, `sub`, [value("f64", -0), value("f64", 1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:437
+assert_return(() => invoke($0, `sub`, [value("f64", 0), value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:438
+assert_return(() => invoke($0, `sub`, [value("f64", 0), value("f64", 1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:439
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:440
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:441
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:442
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:443
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:444
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:445
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:446
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:447
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:448
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:449
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:450
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:451
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:452
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:453
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:454
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:455
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:456
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:457
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:458
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:459
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:460
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:461
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:462
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:463
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:464
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:465
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:466
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:467
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:468
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:469
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:470
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:471
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:472
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:473
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:474
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:475
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:476
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:477
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:478
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:479
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:480
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:481
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:482
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:483
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:484
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:485
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:486
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:487
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:488
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:489
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:490
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:491
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:492
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:493
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:494
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:495
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:496
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:497
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:498
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:499
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:500
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:501
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:502
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:503
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:504
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:505
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+  ],
+);
+
+// ./test/core/f64.wast:506
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/f64.wast:507
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:508
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:509
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:510
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:511
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:512
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:513
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:514
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:515
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:516
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:517
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:518
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:519
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:520
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:521
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:522
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:523
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:524
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:525
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:526
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:527
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:528
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:529
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:530
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:531
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:532
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:533
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:534
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:535
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:536
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:537
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:538
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:539
+assert_return(() => invoke($0, `sub`, [value("f64", -0.5), value("f64", -0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:540
+assert_return(() => invoke($0, `sub`, [value("f64", -0.5), value("f64", 0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:541
+assert_return(() => invoke($0, `sub`, [value("f64", 0.5), value("f64", -0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:542
+assert_return(() => invoke($0, `sub`, [value("f64", 0.5), value("f64", 0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:543
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:544
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:545
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:546
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:547
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:548
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:549
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:550
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:551
+assert_return(() => invoke($0, `sub`, [value("f64", -0.5), value("f64", -0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:552
+assert_return(() => invoke($0, `sub`, [value("f64", -0.5), value("f64", 0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:553
+assert_return(() => invoke($0, `sub`, [value("f64", 0.5), value("f64", -0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:554
+assert_return(() => invoke($0, `sub`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:555
+assert_return(() => invoke($0, `sub`, [value("f64", -0.5), value("f64", -1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:556
+assert_return(() => invoke($0, `sub`, [value("f64", -0.5), value("f64", 1)]), [value("f64", -1.5)]);
+
+// ./test/core/f64.wast:557
+assert_return(() => invoke($0, `sub`, [value("f64", 0.5), value("f64", -1)]), [value("f64", 1.5)]);
+
+// ./test/core/f64.wast:558
+assert_return(() => invoke($0, `sub`, [value("f64", 0.5), value("f64", 1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:559
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", 5.783185307179586)],
+);
+
+// ./test/core/f64.wast:560
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", -6.783185307179586)],
+);
+
+// ./test/core/f64.wast:561
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", 6.783185307179586)],
+);
+
+// ./test/core/f64.wast:562
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", -5.783185307179586)],
+);
+
+// ./test/core/f64.wast:563
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:564
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:565
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:566
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:567
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0.5), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:568
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -0.5), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:569
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0.5), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:570
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 0.5), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:571
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:572
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:573
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:574
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:575
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:576
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:577
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:578
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:579
+assert_return(() => invoke($0, `sub`, [value("f64", -1), value("f64", -0)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:580
+assert_return(() => invoke($0, `sub`, [value("f64", -1), value("f64", 0)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:581
+assert_return(() => invoke($0, `sub`, [value("f64", 1), value("f64", -0)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:582
+assert_return(() => invoke($0, `sub`, [value("f64", 1), value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:583
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:584
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:585
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:586
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:587
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:588
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:589
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:590
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:591
+assert_return(() => invoke($0, `sub`, [value("f64", -1), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:592
+assert_return(() => invoke($0, `sub`, [value("f64", -1), value("f64", 0.5)]), [value("f64", -1.5)]);
+
+// ./test/core/f64.wast:593
+assert_return(() => invoke($0, `sub`, [value("f64", 1), value("f64", -0.5)]), [value("f64", 1.5)]);
+
+// ./test/core/f64.wast:594
+assert_return(() => invoke($0, `sub`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:595
+assert_return(() => invoke($0, `sub`, [value("f64", -1), value("f64", -1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:596
+assert_return(() => invoke($0, `sub`, [value("f64", -1), value("f64", 1)]), [value("f64", -2)]);
+
+// ./test/core/f64.wast:597
+assert_return(() => invoke($0, `sub`, [value("f64", 1), value("f64", -1)]), [value("f64", 2)]);
+
+// ./test/core/f64.wast:598
+assert_return(() => invoke($0, `sub`, [value("f64", 1), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:599
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", 5.283185307179586)],
+);
+
+// ./test/core/f64.wast:600
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", -7.283185307179586)],
+);
+
+// ./test/core/f64.wast:601
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", 7.283185307179586)],
+);
+
+// ./test/core/f64.wast:602
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", -5.283185307179586)],
+);
+
+// ./test/core/f64.wast:603
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:604
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:605
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:606
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:607
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -1), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:608
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -1), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:609
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 1), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:610
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 1), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:611
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:612
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:613
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:614
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:615
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:616
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:617
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:618
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:619
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:620
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:621
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:622
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:623
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:624
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:625
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:626
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:627
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:628
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:629
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:630
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:631
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -5.783185307179586)],
+);
+
+// ./test/core/f64.wast:632
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", -6.783185307179586)],
+);
+
+// ./test/core/f64.wast:633
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", 6.783185307179586)],
+);
+
+// ./test/core/f64.wast:634
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 5.783185307179586)],
+);
+
+// ./test/core/f64.wast:635
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", -5.283185307179586)],
+);
+
+// ./test/core/f64.wast:636
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", -7.283185307179586)],
+);
+
+// ./test/core/f64.wast:637
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", 7.283185307179586)],
+);
+
+// ./test/core/f64.wast:638
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 5.283185307179586)],
+);
+
+// ./test/core/f64.wast:639
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:640
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -12.566370614359172)],
+);
+
+// ./test/core/f64.wast:641
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 12.566370614359172)],
+);
+
+// ./test/core/f64.wast:642
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:643
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:644
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:645
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:646
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:647
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:648
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:649
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:650
+assert_return(
+  () => invoke($0, `sub`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:651
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:652
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:653
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:654
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:655
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:656
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:657
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:658
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:659
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:660
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:661
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:662
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:663
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:664
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:665
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:666
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:667
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:668
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:669
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:670
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:671
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:672
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:673
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:674
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:675
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:676
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:677
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:678
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:679
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:680
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:681
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:682
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:683
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:684
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:685
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:686
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:687
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:688
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:689
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:690
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:691
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:692
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:693
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:694
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:695
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:696
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:697
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:698
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:699
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:700
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", 0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:701
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", -0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:702
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:703
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:704
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:705
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:706
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:707
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:708
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:709
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:710
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:711
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:712
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:713
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:714
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:715
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:716
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", 1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:717
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", -1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:718
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:719
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:720
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:721
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:722
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:723
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:724
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:725
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:726
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:727
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:728
+assert_return(
+  () => invoke($0, `sub`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:729
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:730
+assert_return(
+  () => invoke($0, `sub`, [value("f64", Infinity), value("f64", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:731
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:732
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:733
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:734
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:735
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:736
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:737
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:738
+assert_return(
+  () => invoke($0, `sub`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:739
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:740
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:741
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:742
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:743
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:744
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:745
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:746
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:747
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:748
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:749
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:750
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:751
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:752
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:753
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:754
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:755
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:756
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:757
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:758
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:759
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:760
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:761
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:762
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:763
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:764
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:765
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:766
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:767
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:768
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:769
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:770
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:771
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:772
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:773
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:774
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:775
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:776
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:777
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:778
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:779
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:780
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:781
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:782
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:783
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:784
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:785
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:786
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:787
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:788
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:789
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:790
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:791
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:792
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:793
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:794
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:795
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:796
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:797
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:798
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:799
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:800
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:801
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:802
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:803
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:804
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:805
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:806
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:807
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:808
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:809
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:810
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:811
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:812
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:813
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:814
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:815
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:816
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:817
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:818
+assert_return(
+  () => invoke($0, `sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:819
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:820
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:821
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:822
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:823
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:824
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:825
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:826
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:827
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:828
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:829
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:830
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:831
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", -0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:832
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", 0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:833
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:834
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:835
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", -1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:836
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", 1)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:837
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", -1)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:838
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:839
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:840
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:841
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:842
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:843
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:844
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:845
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:846
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:847
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:848
+assert_return(() => invoke($0, `mul`, [value("f64", -0), value("f64", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:849
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:850
+assert_return(() => invoke($0, `mul`, [value("f64", 0), value("f64", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:851
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:852
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:853
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:854
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:855
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:856
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:857
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:858
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:859
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:860
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:861
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:862
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:863
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:864
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:865
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:866
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:867
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:868
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:869
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:870
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:871
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:872
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:873
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:874
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:875
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:876
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:877
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:878
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:879
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:880
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:881
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:882
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:883
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:884
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:885
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:886
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:887
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:888
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:889
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:890
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:891
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:892
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:893
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:894
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:895
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:896
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:897
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:898
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:899
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:900
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:901
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:902
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:903
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:904
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:905
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:906
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:907
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:908
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:909
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:910
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:911
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:912
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:913
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:914
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:915
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:916
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:917
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:918
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:919
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:920
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:921
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:922
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:923
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:924
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:925
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:926
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:927
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:928
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:929
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:930
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:931
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:932
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:933
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:934
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:935
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:936
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:937
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:938
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:939
+assert_return(() => invoke($0, `mul`, [value("f64", -0.5), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:940
+assert_return(() => invoke($0, `mul`, [value("f64", -0.5), value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:941
+assert_return(() => invoke($0, `mul`, [value("f64", 0.5), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:942
+assert_return(() => invoke($0, `mul`, [value("f64", 0.5), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:943
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:944
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:945
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:946
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:947
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:948
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:949
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:950
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+  ],
+);
+
+// ./test/core/f64.wast:951
+assert_return(() => invoke($0, `mul`, [value("f64", -0.5), value("f64", -0.5)]), [value("f64", 0.25)]);
+
+// ./test/core/f64.wast:952
+assert_return(() => invoke($0, `mul`, [value("f64", -0.5), value("f64", 0.5)]), [value("f64", -0.25)]);
+
+// ./test/core/f64.wast:953
+assert_return(() => invoke($0, `mul`, [value("f64", 0.5), value("f64", -0.5)]), [value("f64", -0.25)]);
+
+// ./test/core/f64.wast:954
+assert_return(() => invoke($0, `mul`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 0.25)]);
+
+// ./test/core/f64.wast:955
+assert_return(() => invoke($0, `mul`, [value("f64", -0.5), value("f64", -1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:956
+assert_return(() => invoke($0, `mul`, [value("f64", -0.5), value("f64", 1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:957
+assert_return(() => invoke($0, `mul`, [value("f64", 0.5), value("f64", -1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:958
+assert_return(() => invoke($0, `mul`, [value("f64", 0.5), value("f64", 1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:959
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", 3.141592653589793)],
+);
+
+// ./test/core/f64.wast:960
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", -3.141592653589793)],
+);
+
+// ./test/core/f64.wast:961
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -3.141592653589793)],
+);
+
+// ./test/core/f64.wast:962
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 3.141592653589793)],
+);
+
+// ./test/core/f64.wast:963
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:964
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:965
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:966
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:967
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -0.5), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:968
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -0.5), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:969
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 0.5), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:970
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 0.5), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:971
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:972
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:973
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:974
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:975
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:976
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:977
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:978
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:979
+assert_return(() => invoke($0, `mul`, [value("f64", -1), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:980
+assert_return(() => invoke($0, `mul`, [value("f64", -1), value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:981
+assert_return(() => invoke($0, `mul`, [value("f64", 1), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:982
+assert_return(() => invoke($0, `mul`, [value("f64", 1), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:983
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:984
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:985
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:986
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:987
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:988
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:989
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:990
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:991
+assert_return(() => invoke($0, `mul`, [value("f64", -1), value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:992
+assert_return(() => invoke($0, `mul`, [value("f64", -1), value("f64", 0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:993
+assert_return(() => invoke($0, `mul`, [value("f64", 1), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:994
+assert_return(() => invoke($0, `mul`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:995
+assert_return(() => invoke($0, `mul`, [value("f64", -1), value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:996
+assert_return(() => invoke($0, `mul`, [value("f64", -1), value("f64", 1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:997
+assert_return(() => invoke($0, `mul`, [value("f64", 1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:998
+assert_return(() => invoke($0, `mul`, [value("f64", 1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:999
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1000
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1001
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1002
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1003
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1004
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1005
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1006
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1007
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -1), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1008
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -1), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1009
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 1), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1010
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 1), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1011
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1012
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1013
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1014
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1015
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1016
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1017
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1018
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1019
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1020
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1021
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1022
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1023
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:1024
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:1025
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:1026
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+  ],
+);
+
+// ./test/core/f64.wast:1027
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:1028
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:1029
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:1030
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+  ],
+);
+
+// ./test/core/f64.wast:1031
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", 3.141592653589793)],
+);
+
+// ./test/core/f64.wast:1032
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", -3.141592653589793)],
+);
+
+// ./test/core/f64.wast:1033
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -3.141592653589793)],
+);
+
+// ./test/core/f64.wast:1034
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 3.141592653589793)],
+);
+
+// ./test/core/f64.wast:1035
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1036
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1037
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1038
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1039
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 39.47841760435743)],
+);
+
+// ./test/core/f64.wast:1040
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -39.47841760435743)],
+);
+
+// ./test/core/f64.wast:1041
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -39.47841760435743)],
+);
+
+// ./test/core/f64.wast:1042
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 39.47841760435743)],
+);
+
+// ./test/core/f64.wast:1043
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1044
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1045
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1046
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1047
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1048
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1049
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1050
+assert_return(
+  () => invoke($0, `mul`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1051
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1052
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1053
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1054
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1055
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1056
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1057
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1058
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1059
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1060
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1061
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1062
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1063
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:1064
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:1065
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:1066
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.0000000000000008881784197001251)],
+);
+
+// ./test/core/f64.wast:1067
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:1068
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:1069
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:1070
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 3.9999999999999996)],
+);
+
+// ./test/core/f64.wast:1071
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1072
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1073
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1074
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1075
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1076
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1077
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1078
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1079
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1080
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1081
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1082
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1083
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1084
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1085
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1086
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1087
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1088
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1089
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1090
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1091
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1092
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1093
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1094
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1095
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1096
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1097
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1098
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1099
+assert_return(() => invoke($0, `mul`, [value("f64", -Infinity), value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1100
+assert_return(() => invoke($0, `mul`, [value("f64", -Infinity), value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1101
+assert_return(() => invoke($0, `mul`, [value("f64", Infinity), value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1102
+assert_return(() => invoke($0, `mul`, [value("f64", Infinity), value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1103
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1104
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1105
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1106
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1107
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1108
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1109
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1110
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1111
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1112
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1113
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1114
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1115
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", -1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1116
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", 1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1117
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1118
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1119
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1120
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1121
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1122
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1123
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1124
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1125
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1126
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1127
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1128
+assert_return(
+  () => invoke($0, `mul`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1129
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1130
+assert_return(
+  () => invoke($0, `mul`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1131
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1132
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1133
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1134
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1135
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1136
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1137
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1138
+assert_return(
+  () => invoke($0, `mul`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1139
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1140
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1141
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1142
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1143
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1144
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1145
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1146
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1147
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1148
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1149
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1150
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1151
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1152
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1153
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1154
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1155
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1156
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1157
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1158
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1159
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1160
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1161
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1162
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1163
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1164
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1165
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1166
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1167
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1168
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1169
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1170
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1171
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1172
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1173
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1174
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1175
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1176
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1177
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1178
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1179
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1180
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1181
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1182
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1183
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1184
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1185
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1186
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1187
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1188
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1189
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1190
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1191
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1192
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1193
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1194
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1195
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1196
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1197
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1198
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1199
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1200
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1201
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1202
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1203
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1204
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1205
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1206
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1207
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1208
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1209
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1210
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1211
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1212
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1213
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1214
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1215
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1216
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1217
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1218
+assert_return(
+  () => invoke($0, `mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1219
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1220
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1221
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1222
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:1223
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1224
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1225
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1226
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1227
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1228
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1229
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1230
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1231
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", -0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1232
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", 0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1233
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1234
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1235
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", -1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1236
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", 1)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1237
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", -1)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1238
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1239
+assert_return(
+  () => invoke($0, `div`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1240
+assert_return(
+  () => invoke($0, `div`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1241
+assert_return(
+  () => invoke($0, `div`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1242
+assert_return(
+  () => invoke($0, `div`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1243
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1244
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1245
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1246
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1247
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", -Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1248
+assert_return(() => invoke($0, `div`, [value("f64", -0), value("f64", Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1249
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", -Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1250
+assert_return(() => invoke($0, `div`, [value("f64", 0), value("f64", Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1251
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1252
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1253
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1254
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1255
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1256
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1257
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1258
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1259
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1260
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1261
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1262
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1263
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1264
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1265
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1266
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1267
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.0000000000000002220446049250313)],
+);
+
+// ./test/core/f64.wast:1268
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.0000000000000002220446049250313)],
+);
+
+// ./test/core/f64.wast:1269
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.0000000000000002220446049250313)],
+);
+
+// ./test/core/f64.wast:1270
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.0000000000000002220446049250313)],
+);
+
+// ./test/core/f64.wast:1271
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:1272
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:1273
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:1274
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/f64.wast:1275
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1276
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1277
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1278
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1279
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1280
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1281
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1282
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1283
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1284
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1285
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1286
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1287
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1288
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1289
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1290
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1291
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1292
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1293
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1294
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1295
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1296
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1297
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1298
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1299
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1300
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1301
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1302
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1303
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 4503599627370496)],
+);
+
+// ./test/core/f64.wast:1304
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -4503599627370496)],
+);
+
+// ./test/core/f64.wast:1305
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -4503599627370496)],
+);
+
+// ./test/core/f64.wast:1306
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 4503599627370496)],
+);
+
+// ./test/core/f64.wast:1307
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1308
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1309
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1310
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1311
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:1312
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:1313
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:1314
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/f64.wast:1315
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1316
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1317
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1318
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1319
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+  ],
+);
+
+// ./test/core/f64.wast:1320
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+  ],
+);
+
+// ./test/core/f64.wast:1321
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+  ],
+);
+
+// ./test/core/f64.wast:1322
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+  ],
+);
+
+// ./test/core/f64.wast:1323
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1324
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1325
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1326
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1327
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1328
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1329
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1330
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1331
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1332
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1333
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1334
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1335
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1336
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1337
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1338
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1339
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", -0)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:1340
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", 0)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:1341
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", -0)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:1342
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", 0)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:1343
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1344
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1345
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1346
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1347
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1348
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1349
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1350
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1351
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", -0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1352
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", 0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1353
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", -0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1354
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1355
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", -1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1356
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", 1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1357
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", -1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1358
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", 1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1359
+assert_return(
+  () => invoke($0, `div`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", 0.07957747154594767)],
+);
+
+// ./test/core/f64.wast:1360
+assert_return(
+  () => invoke($0, `div`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", -0.07957747154594767)],
+);
+
+// ./test/core/f64.wast:1361
+assert_return(
+  () => invoke($0, `div`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -0.07957747154594767)],
+);
+
+// ./test/core/f64.wast:1362
+assert_return(
+  () => invoke($0, `div`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 0.07957747154594767)],
+);
+
+// ./test/core/f64.wast:1363
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+  ],
+);
+
+// ./test/core/f64.wast:1364
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+  ],
+);
+
+// ./test/core/f64.wast:1365
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+  ],
+);
+
+// ./test/core/f64.wast:1366
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+  ],
+);
+
+// ./test/core/f64.wast:1367
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", -Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1368
+assert_return(() => invoke($0, `div`, [value("f64", -0.5), value("f64", Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1369
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", -Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1370
+assert_return(() => invoke($0, `div`, [value("f64", 0.5), value("f64", Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1371
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1372
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1373
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1374
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1375
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1376
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1377
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1378
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1379
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", -0)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:1380
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", 0)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:1381
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", -0)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:1382
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", 0)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:1383
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1384
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1385
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1386
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1387
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1388
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1389
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1390
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1391
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", -0.5)]), [value("f64", 2)]);
+
+// ./test/core/f64.wast:1392
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", 0.5)]), [value("f64", -2)]);
+
+// ./test/core/f64.wast:1393
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", -0.5)]), [value("f64", -2)]);
+
+// ./test/core/f64.wast:1394
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 2)]);
+
+// ./test/core/f64.wast:1395
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1396
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", 1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1397
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1398
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1399
+assert_return(
+  () => invoke($0, `div`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", 0.15915494309189535)],
+);
+
+// ./test/core/f64.wast:1400
+assert_return(
+  () => invoke($0, `div`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", -0.15915494309189535)],
+);
+
+// ./test/core/f64.wast:1401
+assert_return(
+  () => invoke($0, `div`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", -0.15915494309189535)],
+);
+
+// ./test/core/f64.wast:1402
+assert_return(
+  () => invoke($0, `div`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", 0.15915494309189535)],
+);
+
+// ./test/core/f64.wast:1403
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+  ],
+);
+
+// ./test/core/f64.wast:1404
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+  ],
+);
+
+// ./test/core/f64.wast:1405
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+  ],
+);
+
+// ./test/core/f64.wast:1406
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+  ],
+);
+
+// ./test/core/f64.wast:1407
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", -Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1408
+assert_return(() => invoke($0, `div`, [value("f64", -1), value("f64", Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1409
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", -Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1410
+assert_return(() => invoke($0, `div`, [value("f64", 1), value("f64", Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1411
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1412
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1413
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1414
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1415
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1416
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1417
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1418
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1419
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1420
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1421
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1422
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1423
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1424
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1425
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1426
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1427
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1428
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1429
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1430
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1431
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", 12.566370614359172)],
+);
+
+// ./test/core/f64.wast:1432
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", -12.566370614359172)],
+);
+
+// ./test/core/f64.wast:1433
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -12.566370614359172)],
+);
+
+// ./test/core/f64.wast:1434
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 12.566370614359172)],
+);
+
+// ./test/core/f64.wast:1435
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1436
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1437
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1438
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1439
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1440
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1441
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1442
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1443
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+  ],
+);
+
+// ./test/core/f64.wast:1444
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+  ],
+);
+
+// ./test/core/f64.wast:1445
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+  ],
+);
+
+// ./test/core/f64.wast:1446
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+  ],
+);
+
+// ./test/core/f64.wast:1447
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1448
+assert_return(
+  () => invoke($0, `div`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1449
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1450
+assert_return(
+  () => invoke($0, `div`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1451
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1452
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1453
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1454
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1455
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1456
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1457
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1458
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1459
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1460
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1461
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1462
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1463
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1464
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1465
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1466
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1467
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1468
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1469
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1470
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1471
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1472
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1473
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1474
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1475
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1476
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1477
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1478
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1479
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1480
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1481
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1482
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1483
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1484
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1485
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1486
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1487
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1488
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1489
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1490
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1491
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1492
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1493
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1494
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1495
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1496
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1497
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1498
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1499
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", -0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1500
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", 0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1501
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1502
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1503
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1504
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1505
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1506
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1507
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1508
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1509
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1510
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1511
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1512
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1513
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1514
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1515
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", -1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1516
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", 1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1517
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1518
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1519
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1520
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1521
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1522
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1523
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1524
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1525
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1526
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1527
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1528
+assert_return(
+  () => invoke($0, `div`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1529
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1530
+assert_return(
+  () => invoke($0, `div`, [value("f64", Infinity), value("f64", Infinity)]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1531
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1532
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1533
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1534
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1535
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1536
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1537
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1538
+assert_return(
+  () => invoke($0, `div`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1539
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1540
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1541
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1542
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1543
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1544
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1545
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1546
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1547
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1548
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1549
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1550
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1551
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1552
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1553
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1554
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1555
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1556
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1557
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1558
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1559
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1560
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1561
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1562
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1563
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1564
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1565
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1566
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1567
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1568
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1569
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1570
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1571
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1572
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1573
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1574
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1575
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1576
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1577
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1578
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1579
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1580
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1581
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1582
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1583
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1584
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1585
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1586
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1587
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1588
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1589
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1590
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1591
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1592
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1593
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1594
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1595
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1596
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1597
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1598
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1599
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1600
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1601
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1602
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1603
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1604
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1605
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1606
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1607
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1608
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1609
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1610
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1611
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1612
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1613
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1614
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1615
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1616
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1617
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1618
+assert_return(
+  () => invoke($0, `div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1619
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1620
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1621
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1622
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1623
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1624
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1625
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1626
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1627
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1628
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1629
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1630
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1631
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1632
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", 0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1633
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1634
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1635
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1636
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", 1)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1637
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1638
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1639
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1640
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1641
+assert_return(
+  () => invoke($0, `min`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1642
+assert_return(
+  () => invoke($0, `min`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1643
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1644
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1645
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1646
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1647
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1648
+assert_return(() => invoke($0, `min`, [value("f64", -0), value("f64", Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1649
+assert_return(
+  () => invoke($0, `min`, [value("f64", 0), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1650
+assert_return(() => invoke($0, `min`, [value("f64", 0), value("f64", Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1651
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1652
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1653
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1654
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1655
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1656
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1657
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1658
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1659
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1660
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1661
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1662
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1663
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1664
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1665
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1666
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1667
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1668
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1669
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1670
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1671
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1672
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1673
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1674
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1675
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1676
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1677
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1678
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1679
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1680
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1681
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1682
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1683
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1684
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1685
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1686
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1687
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1688
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1689
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1690
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1691
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1692
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1693
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1694
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1695
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1696
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1697
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1698
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1699
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1700
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1701
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1702
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1703
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1704
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1705
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1706
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1707
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1708
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1709
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1710
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1711
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1712
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1713
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1714
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1715
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1716
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1717
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1718
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1719
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1720
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1721
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1722
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1723
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1724
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1725
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1726
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1727
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1728
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1729
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1730
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1731
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1732
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1733
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1734
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1735
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1736
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1737
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1738
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1739
+assert_return(() => invoke($0, `min`, [value("f64", -0.5), value("f64", -0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1740
+assert_return(() => invoke($0, `min`, [value("f64", -0.5), value("f64", 0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1741
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1742
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1743
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1744
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1745
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1746
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1747
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1748
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1749
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1750
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1751
+assert_return(() => invoke($0, `min`, [value("f64", -0.5), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1752
+assert_return(() => invoke($0, `min`, [value("f64", -0.5), value("f64", 0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1753
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1754
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1755
+assert_return(() => invoke($0, `min`, [value("f64", -0.5), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1756
+assert_return(() => invoke($0, `min`, [value("f64", -0.5), value("f64", 1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1757
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1758
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", 1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1759
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1760
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1761
+assert_return(
+  () => invoke($0, `min`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1762
+assert_return(
+  () => invoke($0, `min`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:1763
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1764
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1765
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1766
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:1767
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0.5), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1768
+assert_return(
+  () => invoke($0, `min`, [value("f64", -0.5), value("f64", Infinity)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1769
+assert_return(
+  () => invoke($0, `min`, [value("f64", 0.5), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1770
+assert_return(() => invoke($0, `min`, [value("f64", 0.5), value("f64", Infinity)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1771
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1772
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1773
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1774
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1775
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1776
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1777
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1778
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1779
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", -0)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1780
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", 0)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1781
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1782
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1783
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1784
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1785
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1786
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1787
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1788
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1789
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1790
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1791
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", -0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1792
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", 0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1793
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:1794
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1795
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1796
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", 1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1797
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1798
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1799
+assert_return(
+  () => invoke($0, `min`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1800
+assert_return(
+  () => invoke($0, `min`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1801
+assert_return(
+  () => invoke($0, `min`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1802
+assert_return(
+  () => invoke($0, `min`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1803
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1804
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1805
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1806
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1807
+assert_return(
+  () => invoke($0, `min`, [value("f64", -1), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1808
+assert_return(() => invoke($0, `min`, [value("f64", -1), value("f64", Infinity)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1809
+assert_return(
+  () => invoke($0, `min`, [value("f64", 1), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1810
+assert_return(() => invoke($0, `min`, [value("f64", 1), value("f64", Infinity)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1811
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1812
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1813
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1814
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1815
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1816
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1817
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1818
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1819
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1820
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1821
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1822
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1823
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1824
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1825
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1826
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1827
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1828
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1829
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1830
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1831
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1832
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1833
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1834
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:1835
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1836
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1837
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1838
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1839
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1840
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1841
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1842
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1843
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1844
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1845
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1846
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1847
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1848
+assert_return(
+  () => invoke($0, `min`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1849
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1850
+assert_return(
+  () => invoke($0, `min`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1851
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1852
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1853
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1854
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1855
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1856
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1857
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1858
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1859
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1860
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1861
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:1862
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:1863
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1864
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1865
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1866
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1867
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1868
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1869
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1870
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1871
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1872
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1873
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1874
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:1875
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1876
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1877
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:1878
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:1879
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1880
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1881
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1882
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1883
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1884
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1885
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1886
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1887
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1888
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1889
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1890
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1891
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1892
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1893
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1894
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1895
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1896
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1897
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1898
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1899
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1900
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", 0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1901
+assert_return(() => invoke($0, `min`, [value("f64", Infinity), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:1902
+assert_return(() => invoke($0, `min`, [value("f64", Infinity), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:1903
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1904
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1905
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1906
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:1907
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1908
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1909
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1910
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:1911
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1912
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1913
+assert_return(
+  () => invoke($0, `min`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:1914
+assert_return(() => invoke($0, `min`, [value("f64", Infinity), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:1915
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1916
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", 1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1917
+assert_return(() => invoke($0, `min`, [value("f64", Infinity), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:1918
+assert_return(() => invoke($0, `min`, [value("f64", Infinity), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:1919
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1920
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1921
+assert_return(
+  () => invoke($0, `min`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1922
+assert_return(
+  () => invoke($0, `min`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:1923
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1924
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1925
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1926
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:1927
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1928
+assert_return(
+  () => invoke($0, `min`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1929
+assert_return(
+  () => invoke($0, `min`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:1930
+assert_return(
+  () => invoke($0, `min`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:1931
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1932
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1933
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1934
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1935
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1936
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1937
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1938
+assert_return(
+  () => invoke($0, `min`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1939
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1940
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1941
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1942
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1943
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1944
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1945
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1946
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1947
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1948
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1949
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1950
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1951
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1952
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1953
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1954
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1955
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1956
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1957
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1958
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1959
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1960
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1961
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1962
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1963
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1964
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1965
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1966
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1967
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1968
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1969
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1970
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1971
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1972
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1973
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1974
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1975
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1976
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1977
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1978
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1979
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1980
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1981
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1982
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1983
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1984
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1985
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1986
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1987
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1988
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1989
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1990
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1991
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1992
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1993
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1994
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1995
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1996
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1997
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:1998
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:1999
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2000
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2001
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2002
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2003
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2004
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2005
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2006
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2007
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2008
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2009
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2010
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2011
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2012
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2013
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2014
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2015
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2016
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2017
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2018
+assert_return(
+  () => invoke($0, `min`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2019
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2020
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2021
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2022
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2023
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2024
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2025
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2026
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2027
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2028
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2029
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2030
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2031
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2032
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2033
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", -0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2034
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2035
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", -1)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2036
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2037
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", -1)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2038
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2039
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2040
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2041
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2042
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2043
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2044
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2045
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2046
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2047
+assert_return(() => invoke($0, `max`, [value("f64", -0), value("f64", -Infinity)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2048
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2049
+assert_return(() => invoke($0, `max`, [value("f64", 0), value("f64", -Infinity)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2050
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2051
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2052
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2053
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2054
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2055
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2056
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2057
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2058
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2059
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2060
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2061
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2062
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2063
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2064
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2065
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2066
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2067
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2068
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2069
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2070
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2071
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2072
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2073
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2074
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2075
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2076
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2077
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2078
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2079
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2080
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2081
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2082
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2083
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2084
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2085
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2086
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2087
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2088
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2089
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2090
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2091
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2092
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2093
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2094
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2095
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2096
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2097
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2098
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2099
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2100
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2101
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2102
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2103
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2104
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2105
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2106
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2107
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2108
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2109
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2110
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2111
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2112
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2113
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2114
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2115
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2116
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2117
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2118
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2119
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2120
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2121
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2122
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2123
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2124
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2125
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2126
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2127
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2128
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2129
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2130
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2131
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2132
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2133
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2134
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2135
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2136
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2137
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2138
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2139
+assert_return(() => invoke($0, `max`, [value("f64", -0.5), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2140
+assert_return(() => invoke($0, `max`, [value("f64", -0.5), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2141
+assert_return(() => invoke($0, `max`, [value("f64", 0.5), value("f64", -0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2142
+assert_return(() => invoke($0, `max`, [value("f64", 0.5), value("f64", 0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2143
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2144
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2145
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2146
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2147
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2148
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2149
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2150
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2151
+assert_return(() => invoke($0, `max`, [value("f64", -0.5), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:2152
+assert_return(() => invoke($0, `max`, [value("f64", -0.5), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2153
+assert_return(() => invoke($0, `max`, [value("f64", 0.5), value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2154
+assert_return(() => invoke($0, `max`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2155
+assert_return(() => invoke($0, `max`, [value("f64", -0.5), value("f64", -1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:2156
+assert_return(() => invoke($0, `max`, [value("f64", -0.5), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2157
+assert_return(() => invoke($0, `max`, [value("f64", 0.5), value("f64", -1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2158
+assert_return(() => invoke($0, `max`, [value("f64", 0.5), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2159
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:2160
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2161
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2162
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2163
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:2164
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2165
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2166
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2167
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0.5), value("f64", -Infinity)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:2168
+assert_return(
+  () => invoke($0, `max`, [value("f64", -0.5), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2169
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0.5), value("f64", -Infinity)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2170
+assert_return(
+  () => invoke($0, `max`, [value("f64", 0.5), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2171
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2172
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2173
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2174
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2175
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2176
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2177
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2178
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2179
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2180
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2181
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", -0)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2182
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2183
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2184
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2185
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2186
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2187
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2188
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2189
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2190
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2191
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", -0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64.wast:2192
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64.wast:2193
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", -0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2194
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2195
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2196
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2197
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2198
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2199
+assert_return(
+  () => invoke($0, `max`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:2200
+assert_return(
+  () => invoke($0, `max`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2201
+assert_return(
+  () => invoke($0, `max`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2202
+assert_return(
+  () => invoke($0, `max`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2203
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:2204
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2205
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2206
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2207
+assert_return(() => invoke($0, `max`, [value("f64", -1), value("f64", -Infinity)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2208
+assert_return(
+  () => invoke($0, `max`, [value("f64", -1), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2209
+assert_return(() => invoke($0, `max`, [value("f64", 1), value("f64", -Infinity)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2210
+assert_return(
+  () => invoke($0, `max`, [value("f64", 1), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2211
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2212
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2213
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2214
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2215
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2216
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2217
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2218
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2219
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2220
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2221
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2222
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2223
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2224
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2225
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2226
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2227
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2228
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2229
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2230
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2231
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:2232
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2233
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2234
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2235
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:2236
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2237
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2238
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2239
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2240
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2241
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2242
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2243
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2244
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2245
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2246
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2247
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2248
+assert_return(
+  () => invoke($0, `max`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2249
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2250
+assert_return(
+  () => invoke($0, `max`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2251
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2252
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2253
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2254
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2255
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2256
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2257
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2258
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2259
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2260
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2261
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2262
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2263
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2264
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2265
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2266
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2267
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2268
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2269
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2270
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2271
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:2272
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2273
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2274
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2275
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:2276
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2277
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2278
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2279
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2280
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2281
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2282
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2283
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2284
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2285
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2286
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2287
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2288
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2289
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2290
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2291
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2292
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2293
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2294
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2295
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2296
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2297
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2298
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2299
+assert_return(() => invoke($0, `max`, [value("f64", -Infinity), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2300
+assert_return(() => invoke($0, `max`, [value("f64", -Infinity), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2301
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", -0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2302
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2303
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2304
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64.wast:2305
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2306
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2307
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2308
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64.wast:2309
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2310
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2311
+assert_return(
+  () => invoke($0, `max`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64.wast:2312
+assert_return(
+  () => invoke($0, `max`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64.wast:2313
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2314
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2315
+assert_return(() => invoke($0, `max`, [value("f64", -Infinity), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2316
+assert_return(() => invoke($0, `max`, [value("f64", -Infinity), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2317
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", -1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2318
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2319
+assert_return(
+  () => invoke($0, `max`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2320
+assert_return(
+  () => invoke($0, `max`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64.wast:2321
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2322
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2323
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2324
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2325
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2326
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2327
+assert_return(
+  () => invoke($0, `max`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64.wast:2328
+assert_return(
+  () => invoke($0, `max`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2329
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2330
+assert_return(
+  () => invoke($0, `max`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64.wast:2331
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2332
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2333
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2334
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2335
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2336
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2337
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2338
+assert_return(
+  () => invoke($0, `max`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2339
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2340
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2341
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2342
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2343
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2344
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2345
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2346
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2347
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2348
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2349
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2350
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2351
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2352
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2353
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2354
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2355
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2356
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2357
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2358
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2359
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2360
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2361
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2362
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2363
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2364
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2365
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2366
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2367
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2368
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2369
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2370
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2371
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2372
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2373
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2374
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2375
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2376
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2377
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2378
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2379
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2380
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2381
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2382
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2383
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2384
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2385
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2386
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2387
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2388
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2389
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2390
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2391
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2392
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2393
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2394
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2395
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2396
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2397
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2398
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2399
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2400
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2401
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2402
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2403
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2404
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2405
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2406
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2407
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2408
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2409
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2410
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2411
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2412
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2413
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2414
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2415
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2416
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2417
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2418
+assert_return(
+  () => invoke($0, `max`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2419
+assert_return(() => invoke($0, `sqrt`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2420
+assert_return(() => invoke($0, `sqrt`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2421
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2422
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022227587494850775),
+  ],
+);
+
+// ./test/core/f64.wast:2423
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2424
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014916681462400413),
+  ],
+);
+
+// ./test/core/f64.wast:2425
+assert_return(() => invoke($0, `sqrt`, [value("f64", -0.5)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:2426
+assert_return(() => invoke($0, `sqrt`, [value("f64", 0.5)]), [value("f64", 0.7071067811865476)]);
+
+// ./test/core/f64.wast:2427
+assert_return(() => invoke($0, `sqrt`, [value("f64", -1)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:2428
+assert_return(() => invoke($0, `sqrt`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2429
+assert_return(() => invoke($0, `sqrt`, [value("f64", -6.283185307179586)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:2430
+assert_return(
+  () => invoke($0, `sqrt`, [value("f64", 6.283185307179586)]),
+  [value("f64", 2.5066282746310002)],
+);
+
+// ./test/core/f64.wast:2431
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2432
+assert_return(
+  () => invoke($0, `sqrt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2433
+assert_return(() => invoke($0, `sqrt`, [value("f64", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/f64.wast:2434
+assert_return(() => invoke($0, `sqrt`, [value("f64", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:2435
+assert_return(
+  () => invoke($0, `sqrt`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2436
+assert_return(
+  () => invoke($0, `sqrt`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2437
+assert_return(
+  () => invoke($0, `sqrt`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2438
+assert_return(
+  () => invoke($0, `sqrt`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2439
+assert_return(() => invoke($0, `floor`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2440
+assert_return(() => invoke($0, `floor`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2441
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:2442
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2443
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64.wast:2444
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2445
+assert_return(() => invoke($0, `floor`, [value("f64", -0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2446
+assert_return(() => invoke($0, `floor`, [value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2447
+assert_return(() => invoke($0, `floor`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2448
+assert_return(() => invoke($0, `floor`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2449
+assert_return(() => invoke($0, `floor`, [value("f64", -6.283185307179586)]), [value("f64", -7)]);
+
+// ./test/core/f64.wast:2450
+assert_return(() => invoke($0, `floor`, [value("f64", 6.283185307179586)]), [value("f64", 6)]);
+
+// ./test/core/f64.wast:2451
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2452
+assert_return(
+  () => invoke($0, `floor`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2453
+assert_return(() => invoke($0, `floor`, [value("f64", -Infinity)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:2454
+assert_return(() => invoke($0, `floor`, [value("f64", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:2455
+assert_return(
+  () => invoke($0, `floor`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2456
+assert_return(
+  () => invoke($0, `floor`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2457
+assert_return(
+  () => invoke($0, `floor`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2458
+assert_return(
+  () => invoke($0, `floor`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2459
+assert_return(() => invoke($0, `ceil`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2460
+assert_return(() => invoke($0, `ceil`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2461
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2462
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2463
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2464
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64.wast:2465
+assert_return(() => invoke($0, `ceil`, [value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2466
+assert_return(() => invoke($0, `ceil`, [value("f64", 0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2467
+assert_return(() => invoke($0, `ceil`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2468
+assert_return(() => invoke($0, `ceil`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2469
+assert_return(() => invoke($0, `ceil`, [value("f64", -6.283185307179586)]), [value("f64", -6)]);
+
+// ./test/core/f64.wast:2470
+assert_return(() => invoke($0, `ceil`, [value("f64", 6.283185307179586)]), [value("f64", 7)]);
+
+// ./test/core/f64.wast:2471
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2472
+assert_return(
+  () => invoke($0, `ceil`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2473
+assert_return(() => invoke($0, `ceil`, [value("f64", -Infinity)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:2474
+assert_return(() => invoke($0, `ceil`, [value("f64", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:2475
+assert_return(
+  () => invoke($0, `ceil`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2476
+assert_return(
+  () => invoke($0, `ceil`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2477
+assert_return(
+  () => invoke($0, `ceil`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2478
+assert_return(
+  () => invoke($0, `ceil`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2479
+assert_return(() => invoke($0, `trunc`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2480
+assert_return(() => invoke($0, `trunc`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2481
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2482
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2483
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2484
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2485
+assert_return(() => invoke($0, `trunc`, [value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2486
+assert_return(() => invoke($0, `trunc`, [value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2487
+assert_return(() => invoke($0, `trunc`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2488
+assert_return(() => invoke($0, `trunc`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2489
+assert_return(() => invoke($0, `trunc`, [value("f64", -6.283185307179586)]), [value("f64", -6)]);
+
+// ./test/core/f64.wast:2490
+assert_return(() => invoke($0, `trunc`, [value("f64", 6.283185307179586)]), [value("f64", 6)]);
+
+// ./test/core/f64.wast:2491
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2492
+assert_return(
+  () => invoke($0, `trunc`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2493
+assert_return(() => invoke($0, `trunc`, [value("f64", -Infinity)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:2494
+assert_return(() => invoke($0, `trunc`, [value("f64", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:2495
+assert_return(
+  () => invoke($0, `trunc`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2496
+assert_return(
+  () => invoke($0, `trunc`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2497
+assert_return(
+  () => invoke($0, `trunc`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2498
+assert_return(
+  () => invoke($0, `trunc`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2499
+assert_return(() => invoke($0, `nearest`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2500
+assert_return(() => invoke($0, `nearest`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2501
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2502
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2503
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64.wast:2504
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64.wast:2505
+assert_return(() => invoke($0, `nearest`, [value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64.wast:2506
+assert_return(() => invoke($0, `nearest`, [value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64.wast:2507
+assert_return(() => invoke($0, `nearest`, [value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64.wast:2508
+assert_return(() => invoke($0, `nearest`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64.wast:2509
+assert_return(() => invoke($0, `nearest`, [value("f64", -6.283185307179586)]), [value("f64", -6)]);
+
+// ./test/core/f64.wast:2510
+assert_return(() => invoke($0, `nearest`, [value("f64", 6.283185307179586)]), [value("f64", 6)]);
+
+// ./test/core/f64.wast:2511
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2512
+assert_return(
+  () => invoke($0, `nearest`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64.wast:2513
+assert_return(() => invoke($0, `nearest`, [value("f64", -Infinity)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64.wast:2514
+assert_return(() => invoke($0, `nearest`, [value("f64", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64.wast:2515
+assert_return(
+  () => invoke($0, `nearest`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2516
+assert_return(
+  () => invoke($0, `nearest`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2517
+assert_return(
+  () => invoke($0, `nearest`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/f64.wast:2518
+assert_return(
+  () => invoke($0, `nearest`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/f64.wast:2523
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.add (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2524
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.div (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2525
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.max (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2526
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.min (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2527
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.mul (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2528
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.sub (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2529
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.ceil (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2530
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.floor (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2531
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.nearest (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2532
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.sqrt (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2533
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.trunc (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64.wast:2536
+assert_malformed(
+  () => instantiate(`(func (result f64) (f64.const nan:arithmetic)) `),
+  `unexpected token`,
+);
+
+// ./test/core/f64.wast:2540
+assert_malformed(
+  () => instantiate(`(func (result f64) (f64.const nan:canonical)) `),
+  `unexpected token`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/f64_bitwise.wast.js b/js/src/jit-test/tests/wasm/spec/spec/f64_bitwise.wast.js
new file mode 100644
index 0000000000..3fc6e365b9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/f64_bitwise.wast.js
@@ -0,0 +1,3032 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/f64_bitwise.wast
+
+// ./test/core/f64_bitwise.wast:4
+let $0 = instantiate(`(module
+  (func (export "abs") (param $$x f64) (result f64) (f64.abs (local.get $$x)))
+  (func (export "neg") (param $$x f64) (result f64) (f64.neg (local.get $$x)))
+  (func (export "copysign") (param $$x f64) (param $$y f64) (result f64) (f64.copysign (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/f64_bitwise.wast:10
+assert_return(() => invoke($0, `copysign`, [value("f64", -0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:11
+assert_return(() => invoke($0, `copysign`, [value("f64", -0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:12
+assert_return(() => invoke($0, `copysign`, [value("f64", 0), value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:13
+assert_return(() => invoke($0, `copysign`, [value("f64", 0), value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:14
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:15
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:16
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:17
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:18
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:19
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:20
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:21
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:22
+assert_return(() => invoke($0, `copysign`, [value("f64", -0), value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:23
+assert_return(() => invoke($0, `copysign`, [value("f64", -0), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:24
+assert_return(() => invoke($0, `copysign`, [value("f64", 0), value("f64", -0.5)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:25
+assert_return(() => invoke($0, `copysign`, [value("f64", 0), value("f64", 0.5)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:26
+assert_return(() => invoke($0, `copysign`, [value("f64", -0), value("f64", -1)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:27
+assert_return(() => invoke($0, `copysign`, [value("f64", -0), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:28
+assert_return(() => invoke($0, `copysign`, [value("f64", 0), value("f64", -1)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:29
+assert_return(() => invoke($0, `copysign`, [value("f64", 0), value("f64", 1)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:30
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:31
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:32
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:33
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:34
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:35
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:36
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:37
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:38
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0), value("f64", -Infinity)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:39
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0), value("f64", Infinity)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:40
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0), value("f64", -Infinity)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:41
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0), value("f64", Infinity)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:42
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:43
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:44
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/f64_bitwise.wast:45
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/f64_bitwise.wast:46
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:47
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:48
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:49
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:50
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:51
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:52
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:53
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:54
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:55
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:56
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:57
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:58
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:59
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:60
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:61
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:62
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:63
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:64
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:65
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:66
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:67
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:68
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:69
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:70
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:71
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:72
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:73
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:74
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:75
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:76
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:77
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:78
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:79
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:80
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:81
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:82
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:83
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:84
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:85
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:86
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:87
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:88
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:89
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:90
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:91
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:92
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:93
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:94
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:95
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:96
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:97
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:98
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:99
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:100
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:101
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:102
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:103
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:104
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:105
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:106
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:107
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:108
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:109
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:110
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:111
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:112
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:113
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:114
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:115
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:116
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:117
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:118
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", -0)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:119
+assert_return(() => invoke($0, `copysign`, [value("f64", -0.5), value("f64", 0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:120
+assert_return(() => invoke($0, `copysign`, [value("f64", 0.5), value("f64", -0)]), [value("f64", -0.5)]);
+
+// ./test/core/f64_bitwise.wast:121
+assert_return(() => invoke($0, `copysign`, [value("f64", 0.5), value("f64", 0)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:122
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:123
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:124
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:125
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:126
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:127
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:128
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:129
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:130
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", -0.5)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:131
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", 0.5)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:132
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0.5), value("f64", -0.5)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:133
+assert_return(() => invoke($0, `copysign`, [value("f64", 0.5), value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:134
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", -1)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:135
+assert_return(() => invoke($0, `copysign`, [value("f64", -0.5), value("f64", 1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:136
+assert_return(() => invoke($0, `copysign`, [value("f64", 0.5), value("f64", -1)]), [value("f64", -0.5)]);
+
+// ./test/core/f64_bitwise.wast:137
+assert_return(() => invoke($0, `copysign`, [value("f64", 0.5), value("f64", 1)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:138
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:139
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:140
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:141
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:142
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:143
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:144
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:145
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:146
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", -Infinity)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:147
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -0.5), value("f64", Infinity)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:148
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0.5), value("f64", -Infinity)]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:149
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 0.5), value("f64", Infinity)]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:150
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:151
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:152
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:153
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 0.5)],
+);
+
+// ./test/core/f64_bitwise.wast:154
+assert_return(() => invoke($0, `copysign`, [value("f64", -1), value("f64", -0)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:155
+assert_return(() => invoke($0, `copysign`, [value("f64", -1), value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:156
+assert_return(() => invoke($0, `copysign`, [value("f64", 1), value("f64", -0)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:157
+assert_return(() => invoke($0, `copysign`, [value("f64", 1), value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:158
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:159
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:160
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:161
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:162
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:163
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:164
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:165
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:166
+assert_return(() => invoke($0, `copysign`, [value("f64", -1), value("f64", -0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:167
+assert_return(() => invoke($0, `copysign`, [value("f64", -1), value("f64", 0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:168
+assert_return(() => invoke($0, `copysign`, [value("f64", 1), value("f64", -0.5)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:169
+assert_return(() => invoke($0, `copysign`, [value("f64", 1), value("f64", 0.5)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:170
+assert_return(() => invoke($0, `copysign`, [value("f64", -1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:171
+assert_return(() => invoke($0, `copysign`, [value("f64", -1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:172
+assert_return(() => invoke($0, `copysign`, [value("f64", 1), value("f64", -1)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:173
+assert_return(() => invoke($0, `copysign`, [value("f64", 1), value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:174
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:175
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:176
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:177
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:178
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:179
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:180
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:181
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:182
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -1), value("f64", -Infinity)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:183
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -1), value("f64", Infinity)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:184
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 1), value("f64", -Infinity)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:185
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 1), value("f64", Infinity)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:186
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:187
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:188
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -1)],
+);
+
+// ./test/core/f64_bitwise.wast:189
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/f64_bitwise.wast:190
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:191
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:192
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:193
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:194
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:195
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:196
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:197
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:198
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:199
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:200
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:201
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:202
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:203
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:204
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:205
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:206
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:207
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:208
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:209
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:210
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:211
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:212
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:213
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:214
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:215
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:216
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:217
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:218
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:219
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    value("f64", Infinity),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:220
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", -Infinity),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:221
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    value("f64", Infinity),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:222
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:223
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:224
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:225
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:226
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:227
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:228
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:229
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:230
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:231
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:232
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:233
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:234
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:235
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:236
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:237
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:238
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:239
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:240
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:241
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:242
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:243
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:244
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:245
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:246
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:247
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:248
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:249
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:250
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:251
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:252
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:253
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:254
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:255
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:256
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:257
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:258
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:259
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:260
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:261
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:262
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:263
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:264
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", -0)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:265
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", 0)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:266
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:267
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:268
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:269
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:270
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:271
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:272
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:273
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:274
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:275
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:276
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", -0.5)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:277
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", 0.5)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:278
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:279
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:280
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", -1)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:281
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", 1)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:282
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:283
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:284
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:285
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:286
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:287
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:288
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:289
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:290
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:291
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:292
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:293
+assert_return(
+  () => invoke($0, `copysign`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:294
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:295
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:296
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:297
+assert_return(
+  () => invoke($0, `copysign`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/f64_bitwise.wast:298
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:299
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:300
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:301
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:302
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:303
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:304
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:305
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:306
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:307
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:308
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:309
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:310
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:311
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:312
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:313
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:314
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:315
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:316
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:317
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:318
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:319
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:320
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:321
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:322
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:323
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:324
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:325
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:326
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:327
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:328
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:329
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:330
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:331
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:332
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:333
+assert_return(
+  () => invoke($0, `copysign`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:334
+assert_return(() => invoke($0, `abs`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:335
+assert_return(() => invoke($0, `abs`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:336
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:337
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:338
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:339
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:340
+assert_return(() => invoke($0, `abs`, [value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:341
+assert_return(() => invoke($0, `abs`, [value("f64", 0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:342
+assert_return(() => invoke($0, `abs`, [value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:343
+assert_return(() => invoke($0, `abs`, [value("f64", 1)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:344
+assert_return(
+  () => invoke($0, `abs`, [value("f64", -6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:345
+assert_return(
+  () => invoke($0, `abs`, [value("f64", 6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:346
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:347
+assert_return(
+  () => invoke($0, `abs`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:348
+assert_return(() => invoke($0, `abs`, [value("f64", -Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64_bitwise.wast:349
+assert_return(() => invoke($0, `abs`, [value("f64", Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64_bitwise.wast:350
+assert_return(
+  () => invoke($0, `abs`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:351
+assert_return(
+  () => invoke($0, `abs`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:352
+assert_return(() => invoke($0, `neg`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/f64_bitwise.wast:353
+assert_return(() => invoke($0, `neg`, [value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/f64_bitwise.wast:354
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:355
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:356
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:357
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:358
+assert_return(() => invoke($0, `neg`, [value("f64", -0.5)]), [value("f64", 0.5)]);
+
+// ./test/core/f64_bitwise.wast:359
+assert_return(() => invoke($0, `neg`, [value("f64", 0.5)]), [value("f64", -0.5)]);
+
+// ./test/core/f64_bitwise.wast:360
+assert_return(() => invoke($0, `neg`, [value("f64", -1)]), [value("f64", 1)]);
+
+// ./test/core/f64_bitwise.wast:361
+assert_return(() => invoke($0, `neg`, [value("f64", 1)]), [value("f64", -1)]);
+
+// ./test/core/f64_bitwise.wast:362
+assert_return(
+  () => invoke($0, `neg`, [value("f64", -6.283185307179586)]),
+  [value("f64", 6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:363
+assert_return(
+  () => invoke($0, `neg`, [value("f64", 6.283185307179586)]),
+  [value("f64", -6.283185307179586)],
+);
+
+// ./test/core/f64_bitwise.wast:364
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:365
+assert_return(
+  () => invoke($0, `neg`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/f64_bitwise.wast:366
+assert_return(() => invoke($0, `neg`, [value("f64", -Infinity)]), [value("f64", Infinity)]);
+
+// ./test/core/f64_bitwise.wast:367
+assert_return(() => invoke($0, `neg`, [value("f64", Infinity)]), [value("f64", -Infinity)]);
+
+// ./test/core/f64_bitwise.wast:368
+assert_return(
+  () => invoke($0, `neg`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/f64_bitwise.wast:369
+assert_return(
+  () => invoke($0, `neg`, [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/f64_bitwise.wast:374
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.copysign (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_bitwise.wast:375
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.abs (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_bitwise.wast:376
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.neg (i64.const 0))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/f64_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/f64_cmp.wast.js
new file mode 100644
index 0000000000..45ea523bcd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/f64_cmp.wast.js
@@ -0,0 +1,18854 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/f64_cmp.wast
+
+// ./test/core/f64_cmp.wast:4
+let $0 = instantiate(`(module
+  (func (export "eq") (param $$x f64) (param $$y f64) (result i32) (f64.eq (local.get $$x) (local.get $$y)))
+  (func (export "ne") (param $$x f64) (param $$y f64) (result i32) (f64.ne (local.get $$x) (local.get $$y)))
+  (func (export "lt") (param $$x f64) (param $$y f64) (result i32) (f64.lt (local.get $$x) (local.get $$y)))
+  (func (export "le") (param $$x f64) (param $$y f64) (result i32) (f64.le (local.get $$x) (local.get $$y)))
+  (func (export "gt") (param $$x f64) (param $$y f64) (result i32) (f64.gt (local.get $$x) (local.get $$y)))
+  (func (export "ge") (param $$x f64) (param $$y f64) (result i32) (f64.ge (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/f64_cmp.wast:13
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:14
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:15
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:16
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:17
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:18
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:19
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:20
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:21
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:22
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:23
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:24
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:25
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:26
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:27
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:28
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:29
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:30
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:31
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:32
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:33
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:34
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:35
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:36
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:37
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:38
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:39
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:40
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:41
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:42
+assert_return(() => invoke($0, `eq`, [value("f64", -0), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:43
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:44
+assert_return(() => invoke($0, `eq`, [value("f64", 0), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:45
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:46
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:47
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:48
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:49
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:50
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:51
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:52
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:53
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:54
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:55
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:56
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:57
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:58
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:59
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:60
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:61
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:62
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:63
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:64
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:65
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:66
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:67
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:68
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:69
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:70
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:71
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:72
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:73
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:74
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:75
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:76
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:77
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:78
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:79
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:80
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:81
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:82
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:83
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:84
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:85
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:86
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:87
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:88
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:89
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:90
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:91
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:92
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:93
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:94
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:95
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:96
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:97
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:98
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:99
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:100
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:101
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:102
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:103
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:104
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:105
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:106
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:107
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:108
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:109
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:110
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:111
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:112
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:113
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:114
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:115
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:116
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:117
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:118
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:119
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:120
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:121
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:122
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:123
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:124
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:125
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:126
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:127
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:128
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:129
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:130
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:131
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:132
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:133
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:134
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:135
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:136
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:137
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:138
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:139
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:140
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:141
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:142
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:143
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:144
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:145
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:146
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:147
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:148
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:149
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:150
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:151
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:152
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:153
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:154
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:155
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:156
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:157
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:158
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:159
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:160
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:161
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:162
+assert_return(() => invoke($0, `eq`, [value("f64", -0.5), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:163
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:164
+assert_return(() => invoke($0, `eq`, [value("f64", 0.5), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:165
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:166
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:167
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:168
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:169
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:170
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:171
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:172
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:173
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:174
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:175
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:176
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:177
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:178
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:179
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:180
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:181
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:182
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:183
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:184
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:185
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:186
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:187
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:188
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:189
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:190
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:191
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:192
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:193
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:194
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:195
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:196
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:197
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:198
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:199
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:200
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:201
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:202
+assert_return(() => invoke($0, `eq`, [value("f64", -1), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:203
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:204
+assert_return(() => invoke($0, `eq`, [value("f64", 1), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:205
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:206
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:207
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:208
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:209
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:210
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:211
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:212
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:213
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:214
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:215
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:216
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:217
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:218
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:219
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:220
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:221
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:222
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:223
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:224
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:225
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:226
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:227
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:228
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:229
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:230
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:231
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:232
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:233
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:234
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:235
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:236
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:237
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:238
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:239
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:240
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:241
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:242
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:243
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:244
+assert_return(
+  () => invoke($0, `eq`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:245
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:246
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:247
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:248
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:249
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:250
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:251
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:252
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:253
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:254
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:255
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:256
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:257
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:258
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:259
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:260
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:261
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:262
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:263
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:264
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:265
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:266
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:267
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:268
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:269
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:270
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:271
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:272
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:273
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:274
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:275
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:276
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:277
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:278
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:279
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:280
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:281
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:282
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:283
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:284
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:285
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:286
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:287
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:288
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:289
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:290
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:291
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:292
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:293
+assert_return(() => invoke($0, `eq`, [value("f64", -Infinity), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:294
+assert_return(() => invoke($0, `eq`, [value("f64", -Infinity), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:295
+assert_return(() => invoke($0, `eq`, [value("f64", Infinity), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:296
+assert_return(() => invoke($0, `eq`, [value("f64", Infinity), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:297
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:298
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:299
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:300
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:301
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:302
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:303
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:304
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:305
+assert_return(() => invoke($0, `eq`, [value("f64", -Infinity), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:306
+assert_return(() => invoke($0, `eq`, [value("f64", -Infinity), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:307
+assert_return(() => invoke($0, `eq`, [value("f64", Infinity), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:308
+assert_return(() => invoke($0, `eq`, [value("f64", Infinity), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:309
+assert_return(() => invoke($0, `eq`, [value("f64", -Infinity), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:310
+assert_return(() => invoke($0, `eq`, [value("f64", -Infinity), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:311
+assert_return(() => invoke($0, `eq`, [value("f64", Infinity), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:312
+assert_return(() => invoke($0, `eq`, [value("f64", Infinity), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:313
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:314
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:315
+assert_return(
+  () => invoke($0, `eq`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:316
+assert_return(
+  () => invoke($0, `eq`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:317
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:318
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:319
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:320
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:321
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:322
+assert_return(
+  () => invoke($0, `eq`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:323
+assert_return(
+  () => invoke($0, `eq`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:324
+assert_return(
+  () => invoke($0, `eq`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:325
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:326
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:327
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:328
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:329
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:330
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:331
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:332
+assert_return(
+  () => invoke($0, `eq`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:333
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:334
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:335
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:336
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:337
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:338
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:339
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:340
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:341
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:342
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:343
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:344
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:345
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:346
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:347
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:348
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:349
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:350
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:351
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:352
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:353
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:354
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:355
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:356
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:357
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:358
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:359
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:360
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:361
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:362
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:363
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:364
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:365
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:366
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:367
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:368
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:369
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:370
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:371
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:372
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:373
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:374
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:375
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:376
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:377
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:378
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:379
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:380
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:381
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:382
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:383
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:384
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:385
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:386
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:387
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:388
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:389
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:390
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:391
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:392
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:393
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:394
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:395
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:396
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:397
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:398
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:399
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:400
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:401
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:402
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:403
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:404
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:405
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:406
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:407
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:408
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:409
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:410
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:411
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:412
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:413
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:414
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:415
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:416
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:417
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:418
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:419
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:420
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:421
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:422
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:423
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:424
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:425
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:426
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:427
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:428
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:429
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:430
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:431
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:432
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:433
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:434
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:435
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:436
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:437
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:438
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:439
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:440
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:441
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:442
+assert_return(() => invoke($0, `ne`, [value("f64", -0), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:443
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:444
+assert_return(() => invoke($0, `ne`, [value("f64", 0), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:445
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:446
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:447
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:448
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:449
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:450
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:451
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:452
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:453
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:454
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:455
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:456
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:457
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:458
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:459
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:460
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:461
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:462
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:463
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:464
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:465
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:466
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:467
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:468
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:469
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:470
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:471
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:472
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:473
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:474
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:475
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:476
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:477
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:478
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:479
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:480
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:481
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:482
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:483
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:484
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:485
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:486
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:487
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:488
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:489
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:490
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:491
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:492
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:493
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:494
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:495
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:496
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:497
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:498
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:499
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:500
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:501
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:502
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:503
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:504
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:505
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:506
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:507
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:508
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:509
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:510
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:511
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:512
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:513
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:514
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:515
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:516
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:517
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:518
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:519
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:520
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:521
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:522
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:523
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:524
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:525
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:526
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:527
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:528
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:529
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:530
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:531
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:532
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:533
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:534
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:535
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:536
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:537
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:538
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:539
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:540
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:541
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:542
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:543
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:544
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:545
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:546
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:547
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:548
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:549
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:550
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:551
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:552
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:553
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:554
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:555
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:556
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:557
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:558
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:559
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:560
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:561
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:562
+assert_return(() => invoke($0, `ne`, [value("f64", -0.5), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:563
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:564
+assert_return(() => invoke($0, `ne`, [value("f64", 0.5), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:565
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:566
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:567
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:568
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:569
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:570
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:571
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:572
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:573
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:574
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:575
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:576
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:577
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:578
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:579
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:580
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:581
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:582
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:583
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:584
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:585
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:586
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:587
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:588
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:589
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:590
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:591
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:592
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:593
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:594
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:595
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:596
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:597
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:598
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:599
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:600
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:601
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:602
+assert_return(() => invoke($0, `ne`, [value("f64", -1), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:603
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:604
+assert_return(() => invoke($0, `ne`, [value("f64", 1), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:605
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:606
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:607
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:608
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:609
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:610
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:611
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:612
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:613
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:614
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:615
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:616
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:617
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:618
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:619
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:620
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:621
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:622
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:623
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:624
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:625
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:626
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:627
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:628
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:629
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:630
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:631
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:632
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:633
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:634
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:635
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:636
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:637
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:638
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:639
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:640
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:641
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:642
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:643
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:644
+assert_return(
+  () => invoke($0, `ne`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:645
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:646
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:647
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:648
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:649
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:650
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:651
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:652
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:653
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:654
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:655
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:656
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:657
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:658
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:659
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:660
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:661
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:662
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:663
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:664
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:665
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:666
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:667
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:668
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:669
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:670
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:671
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:672
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:673
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:674
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:675
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:676
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:677
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:678
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:679
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:680
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:681
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:682
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:683
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:684
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:685
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:686
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:687
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:688
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:689
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:690
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:691
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:692
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:693
+assert_return(() => invoke($0, `ne`, [value("f64", -Infinity), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:694
+assert_return(() => invoke($0, `ne`, [value("f64", -Infinity), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:695
+assert_return(() => invoke($0, `ne`, [value("f64", Infinity), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:696
+assert_return(() => invoke($0, `ne`, [value("f64", Infinity), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:697
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:698
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:699
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:700
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:701
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:702
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:703
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:704
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:705
+assert_return(() => invoke($0, `ne`, [value("f64", -Infinity), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:706
+assert_return(() => invoke($0, `ne`, [value("f64", -Infinity), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:707
+assert_return(() => invoke($0, `ne`, [value("f64", Infinity), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:708
+assert_return(() => invoke($0, `ne`, [value("f64", Infinity), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:709
+assert_return(() => invoke($0, `ne`, [value("f64", -Infinity), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:710
+assert_return(() => invoke($0, `ne`, [value("f64", -Infinity), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:711
+assert_return(() => invoke($0, `ne`, [value("f64", Infinity), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:712
+assert_return(() => invoke($0, `ne`, [value("f64", Infinity), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:713
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:714
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:715
+assert_return(
+  () => invoke($0, `ne`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:716
+assert_return(
+  () => invoke($0, `ne`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:717
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:718
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:719
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:720
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:721
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:722
+assert_return(
+  () => invoke($0, `ne`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:723
+assert_return(
+  () => invoke($0, `ne`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:724
+assert_return(
+  () => invoke($0, `ne`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:725
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:726
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:727
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:728
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:729
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:730
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:731
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:732
+assert_return(
+  () => invoke($0, `ne`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:733
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:734
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:735
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:736
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:737
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:738
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:739
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:740
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:741
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:742
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:743
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:744
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:745
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:746
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:747
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:748
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:749
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:750
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:751
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:752
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:753
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:754
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:755
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:756
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:757
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:758
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:759
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:760
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:761
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:762
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:763
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:764
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:765
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:766
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:767
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:768
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:769
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:770
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:771
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:772
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:773
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:774
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:775
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:776
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:777
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:778
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:779
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:780
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:781
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:782
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:783
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:784
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:785
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:786
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:787
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:788
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:789
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:790
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:791
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:792
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:793
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:794
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:795
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:796
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:797
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:798
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:799
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:800
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:801
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:802
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:803
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:804
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:805
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:806
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:807
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:808
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:809
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:810
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:811
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:812
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:813
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:814
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:815
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:816
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:817
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:818
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:819
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:820
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:821
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:822
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:823
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:824
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:825
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:826
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:827
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:828
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:829
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:830
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:831
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:832
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:833
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:834
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:835
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:836
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:837
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:838
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:839
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:840
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:841
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:842
+assert_return(() => invoke($0, `lt`, [value("f64", -0), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:843
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:844
+assert_return(() => invoke($0, `lt`, [value("f64", 0), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:845
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:846
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:847
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:848
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:849
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:850
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:851
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:852
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:853
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:854
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:855
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:856
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:857
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:858
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:859
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:860
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:861
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:862
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:863
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:864
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:865
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:866
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:867
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:868
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:869
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:870
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:871
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:872
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:873
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:874
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:875
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:876
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:877
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:878
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:879
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:880
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:881
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:882
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:883
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:884
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:885
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:886
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:887
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:888
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:889
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:890
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:891
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:892
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:893
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:894
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:895
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:896
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:897
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:898
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:899
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:900
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:901
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:902
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:903
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:904
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:905
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:906
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:907
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:908
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:909
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:910
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:911
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:912
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:913
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:914
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:915
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:916
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:917
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:918
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:919
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:920
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:921
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:922
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:923
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:924
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:925
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:926
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:927
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:928
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:929
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:930
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:931
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:932
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:933
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:934
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:935
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:936
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:937
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:938
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:939
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:940
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:941
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:942
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:943
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:944
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:945
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:946
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:947
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:948
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:949
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:950
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:951
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:952
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:953
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:954
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:955
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:956
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:957
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:958
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:959
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:960
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:961
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:962
+assert_return(() => invoke($0, `lt`, [value("f64", -0.5), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:963
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:964
+assert_return(() => invoke($0, `lt`, [value("f64", 0.5), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:965
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:966
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:967
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:968
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:969
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:970
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:971
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:972
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:973
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:974
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:975
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:976
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:977
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:978
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:979
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:980
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:981
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:982
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:983
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:984
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:985
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:986
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:987
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:988
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:989
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:990
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:991
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:992
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:993
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:994
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:995
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:996
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:997
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:998
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:999
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1000
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1001
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1002
+assert_return(() => invoke($0, `lt`, [value("f64", -1), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1003
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1004
+assert_return(() => invoke($0, `lt`, [value("f64", 1), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1005
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1006
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1007
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1008
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1009
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1010
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1011
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1012
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1013
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1014
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1015
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1016
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1017
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1018
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1019
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1020
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1021
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1022
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1023
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1024
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1025
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1026
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1027
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1028
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1029
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1030
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1031
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1032
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1033
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1034
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1035
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1036
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1037
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1038
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1039
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1040
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1041
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1042
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1043
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1044
+assert_return(
+  () => invoke($0, `lt`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1045
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1046
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1047
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1048
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1049
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1050
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1051
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1052
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1053
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1054
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1055
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1056
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1057
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1058
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1059
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1060
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1061
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1062
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1063
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1064
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1065
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1066
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1067
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1068
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1069
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1070
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1071
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1072
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1073
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1074
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1075
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1076
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1077
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1078
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1079
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1080
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1081
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1082
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1083
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1084
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1085
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1086
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1087
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1088
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1089
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1090
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1091
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1092
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1093
+assert_return(() => invoke($0, `lt`, [value("f64", -Infinity), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1094
+assert_return(() => invoke($0, `lt`, [value("f64", -Infinity), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1095
+assert_return(() => invoke($0, `lt`, [value("f64", Infinity), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1096
+assert_return(() => invoke($0, `lt`, [value("f64", Infinity), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1097
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1098
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1099
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1100
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1101
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1102
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1103
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1104
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1105
+assert_return(() => invoke($0, `lt`, [value("f64", -Infinity), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1106
+assert_return(() => invoke($0, `lt`, [value("f64", -Infinity), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1107
+assert_return(() => invoke($0, `lt`, [value("f64", Infinity), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1108
+assert_return(() => invoke($0, `lt`, [value("f64", Infinity), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1109
+assert_return(() => invoke($0, `lt`, [value("f64", -Infinity), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1110
+assert_return(() => invoke($0, `lt`, [value("f64", -Infinity), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1111
+assert_return(() => invoke($0, `lt`, [value("f64", Infinity), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1112
+assert_return(() => invoke($0, `lt`, [value("f64", Infinity), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1113
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1114
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1115
+assert_return(
+  () => invoke($0, `lt`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1116
+assert_return(
+  () => invoke($0, `lt`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1117
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1118
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1119
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1120
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1121
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1122
+assert_return(
+  () => invoke($0, `lt`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1123
+assert_return(
+  () => invoke($0, `lt`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1124
+assert_return(
+  () => invoke($0, `lt`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1125
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1126
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1127
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1128
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1129
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1130
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1131
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1132
+assert_return(
+  () => invoke($0, `lt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1133
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1134
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1135
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1136
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1137
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1138
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1139
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1140
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1141
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1142
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1143
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1144
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1145
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1146
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1147
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1148
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1149
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1150
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1151
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1152
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1153
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1154
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1155
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1156
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1157
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1158
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1159
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1160
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1161
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1162
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1163
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1164
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1165
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1166
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1167
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1168
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1169
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1170
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1171
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1172
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1173
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1174
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1175
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1176
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1177
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1178
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1179
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1180
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1181
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1182
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1183
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1184
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1185
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1186
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1187
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1188
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1189
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1190
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1191
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1192
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1193
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1194
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1195
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1196
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1197
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1198
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1199
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1200
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1201
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1202
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1203
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1204
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1205
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1206
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1207
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1208
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1209
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1210
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1211
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1212
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1213
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1214
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1215
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1216
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1217
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1218
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1219
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1220
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1221
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1222
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1223
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1224
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1225
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1226
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1227
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1228
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1229
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1230
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1231
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1232
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1233
+assert_return(
+  () => invoke($0, `le`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1234
+assert_return(
+  () => invoke($0, `le`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1235
+assert_return(
+  () => invoke($0, `le`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1236
+assert_return(
+  () => invoke($0, `le`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1237
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1238
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1239
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1240
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1241
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1242
+assert_return(() => invoke($0, `le`, [value("f64", -0), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1243
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1244
+assert_return(() => invoke($0, `le`, [value("f64", 0), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1245
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1246
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1247
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1248
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1249
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1250
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1251
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1252
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1253
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1254
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1255
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1256
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1257
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1258
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1259
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1260
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1261
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1262
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1263
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1264
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1265
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1266
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1267
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1268
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1269
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1270
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1271
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1272
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1273
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1274
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1275
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1276
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1277
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1278
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1279
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1280
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1281
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1282
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1283
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1284
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1285
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1286
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1287
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1288
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1289
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1290
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1291
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1292
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1293
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1294
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1295
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1296
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1297
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1298
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1299
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1300
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1301
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1302
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1303
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1304
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1305
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1306
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1307
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1308
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1309
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1310
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1311
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1312
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1313
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1314
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1315
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1316
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1317
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1318
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1319
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1320
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1321
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1322
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1323
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1324
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1325
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1326
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1327
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1328
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1329
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1330
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1331
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1332
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1333
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1334
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1335
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1336
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1337
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1338
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1339
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1340
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1341
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1342
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1343
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1344
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1345
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1346
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1347
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1348
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1349
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1350
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1351
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1352
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1353
+assert_return(
+  () => invoke($0, `le`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1354
+assert_return(
+  () => invoke($0, `le`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1355
+assert_return(
+  () => invoke($0, `le`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1356
+assert_return(
+  () => invoke($0, `le`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1357
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1358
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1359
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1360
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1361
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1362
+assert_return(() => invoke($0, `le`, [value("f64", -0.5), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1363
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1364
+assert_return(() => invoke($0, `le`, [value("f64", 0.5), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1365
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1366
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1367
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1368
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1369
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1370
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1371
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1372
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1373
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1374
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1375
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1376
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1377
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1378
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1379
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1380
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1381
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1382
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1383
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1384
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1385
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1386
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1387
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1388
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1389
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1390
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1391
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1392
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1393
+assert_return(
+  () => invoke($0, `le`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1394
+assert_return(
+  () => invoke($0, `le`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1395
+assert_return(
+  () => invoke($0, `le`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1396
+assert_return(
+  () => invoke($0, `le`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1397
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1398
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1399
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1400
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1401
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1402
+assert_return(() => invoke($0, `le`, [value("f64", -1), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1403
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", -Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1404
+assert_return(() => invoke($0, `le`, [value("f64", 1), value("f64", Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1405
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1406
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1407
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1408
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1409
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1410
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1411
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1412
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1413
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1414
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1415
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1416
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1417
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1418
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1419
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1420
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1421
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1422
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1423
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1424
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1425
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1426
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1427
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1428
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1429
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1430
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1431
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1432
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1433
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1434
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1435
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1436
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1437
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1438
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1439
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1440
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1441
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1442
+assert_return(
+  () => invoke($0, `le`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1443
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1444
+assert_return(
+  () => invoke($0, `le`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1445
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1446
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1447
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1448
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1449
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1450
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1451
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1452
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1453
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1454
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1455
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1456
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1457
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1458
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1459
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1460
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1461
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1462
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1463
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1464
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1465
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1466
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1467
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1468
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1469
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1470
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1471
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1472
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1473
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1474
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1475
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1476
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1477
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1478
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1479
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1480
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1481
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1482
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1483
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1484
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1485
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1486
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1487
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1488
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1489
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1490
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1491
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1492
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1493
+assert_return(() => invoke($0, `le`, [value("f64", -Infinity), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1494
+assert_return(() => invoke($0, `le`, [value("f64", -Infinity), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1495
+assert_return(() => invoke($0, `le`, [value("f64", Infinity), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1496
+assert_return(() => invoke($0, `le`, [value("f64", Infinity), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1497
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1498
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1499
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1500
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1501
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1502
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1503
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1504
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1505
+assert_return(() => invoke($0, `le`, [value("f64", -Infinity), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1506
+assert_return(() => invoke($0, `le`, [value("f64", -Infinity), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1507
+assert_return(() => invoke($0, `le`, [value("f64", Infinity), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1508
+assert_return(() => invoke($0, `le`, [value("f64", Infinity), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1509
+assert_return(() => invoke($0, `le`, [value("f64", -Infinity), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1510
+assert_return(() => invoke($0, `le`, [value("f64", -Infinity), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1511
+assert_return(() => invoke($0, `le`, [value("f64", Infinity), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1512
+assert_return(() => invoke($0, `le`, [value("f64", Infinity), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1513
+assert_return(
+  () => invoke($0, `le`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1514
+assert_return(
+  () => invoke($0, `le`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1515
+assert_return(
+  () => invoke($0, `le`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1516
+assert_return(
+  () => invoke($0, `le`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1517
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1518
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1519
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1520
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1521
+assert_return(
+  () => invoke($0, `le`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1522
+assert_return(
+  () => invoke($0, `le`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1523
+assert_return(
+  () => invoke($0, `le`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1524
+assert_return(
+  () => invoke($0, `le`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1525
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1526
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1527
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1528
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1529
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1530
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1531
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1532
+assert_return(
+  () => invoke($0, `le`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1533
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1534
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1535
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1536
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1537
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1538
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1539
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1540
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1541
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1542
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1543
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1544
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1545
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1546
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1547
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1548
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1549
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1550
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1551
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1552
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1553
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1554
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1555
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1556
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1557
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1558
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1559
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1560
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1561
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1562
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1563
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1564
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1565
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1566
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1567
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1568
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1569
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1570
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1571
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1572
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1573
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1574
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1575
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1576
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1577
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1578
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1579
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1580
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1581
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1582
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1583
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1584
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1585
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1586
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1587
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1588
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1589
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1590
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1591
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1592
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1593
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1594
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1595
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1596
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1597
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1598
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1599
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1600
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1601
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1602
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1603
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1604
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1605
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1606
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1607
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1608
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1609
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1610
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1611
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1612
+assert_return(
+  () => invoke($0, `le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1613
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1614
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1615
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1616
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1617
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1618
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1619
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1620
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1621
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1622
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1623
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1624
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1625
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1626
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1627
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1628
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1629
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1630
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1631
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1632
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1633
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1634
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1635
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1636
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1637
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1638
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1639
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1640
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1641
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1642
+assert_return(() => invoke($0, `gt`, [value("f64", -0), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1643
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1644
+assert_return(() => invoke($0, `gt`, [value("f64", 0), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1645
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1646
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1647
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1648
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1649
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1650
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1651
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1652
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1653
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1654
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1655
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1656
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1657
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1658
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1659
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1660
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1661
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1662
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1663
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1664
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1665
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1666
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1667
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1668
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1669
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1670
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1671
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1672
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1673
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1674
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1675
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1676
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1677
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1678
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1679
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1680
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1681
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1682
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1683
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1684
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1685
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1686
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1687
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1688
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1689
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1690
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1691
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1692
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1693
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1694
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1695
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1696
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1697
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1698
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1699
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1700
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1701
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1702
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1703
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1704
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1705
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1706
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1707
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1708
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1709
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1710
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1711
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1712
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1713
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1714
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1715
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1716
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1717
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1718
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1719
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1720
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1721
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1722
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1723
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1724
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1725
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1726
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1727
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1728
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1729
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1730
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1731
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1732
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1733
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1734
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1735
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1736
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1737
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1738
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1739
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1740
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1741
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1742
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1743
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1744
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1745
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1746
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1747
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1748
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1749
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1750
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1751
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1752
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1753
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1754
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1755
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1756
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1757
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1758
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1759
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1760
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1761
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1762
+assert_return(() => invoke($0, `gt`, [value("f64", -0.5), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1763
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1764
+assert_return(() => invoke($0, `gt`, [value("f64", 0.5), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1765
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1766
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1767
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1768
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1769
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1770
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1771
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1772
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1773
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1774
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1775
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1776
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1777
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1778
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1779
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1780
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1781
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1782
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1783
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1784
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1785
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1786
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1787
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1788
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1789
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1790
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1791
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1792
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1793
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1794
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1795
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1796
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1797
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1798
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1799
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1800
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1801
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1802
+assert_return(() => invoke($0, `gt`, [value("f64", -1), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1803
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1804
+assert_return(() => invoke($0, `gt`, [value("f64", 1), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1805
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1806
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1807
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1808
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1809
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1810
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1811
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1812
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1813
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1814
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1815
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1816
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1817
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1818
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1819
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1820
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1821
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1822
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1823
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1824
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1825
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1826
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1827
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1828
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1829
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1830
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1831
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1832
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1833
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1834
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1835
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1836
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1837
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1838
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1839
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1840
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1841
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1842
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1843
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1844
+assert_return(
+  () => invoke($0, `gt`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1845
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1846
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1847
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1848
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1849
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1850
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1851
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1852
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1853
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1854
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1855
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1856
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1857
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1858
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1859
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1860
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1861
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1862
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1863
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1864
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1865
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1866
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1867
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1868
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1869
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1870
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1871
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1872
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1873
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1874
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1875
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1876
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1877
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1878
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1879
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1880
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1881
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1882
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1883
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1884
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1885
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1886
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1887
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1888
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1889
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1890
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1891
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1892
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1893
+assert_return(() => invoke($0, `gt`, [value("f64", -Infinity), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1894
+assert_return(() => invoke($0, `gt`, [value("f64", -Infinity), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1895
+assert_return(() => invoke($0, `gt`, [value("f64", Infinity), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1896
+assert_return(() => invoke($0, `gt`, [value("f64", Infinity), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1897
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1898
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1899
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1900
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1901
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1902
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1903
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1904
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1905
+assert_return(() => invoke($0, `gt`, [value("f64", -Infinity), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1906
+assert_return(() => invoke($0, `gt`, [value("f64", -Infinity), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1907
+assert_return(() => invoke($0, `gt`, [value("f64", Infinity), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1908
+assert_return(() => invoke($0, `gt`, [value("f64", Infinity), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1909
+assert_return(() => invoke($0, `gt`, [value("f64", -Infinity), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1910
+assert_return(() => invoke($0, `gt`, [value("f64", -Infinity), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:1911
+assert_return(() => invoke($0, `gt`, [value("f64", Infinity), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1912
+assert_return(() => invoke($0, `gt`, [value("f64", Infinity), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:1913
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1914
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1915
+assert_return(
+  () => invoke($0, `gt`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1916
+assert_return(
+  () => invoke($0, `gt`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1917
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1918
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1919
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1920
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1921
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1922
+assert_return(
+  () => invoke($0, `gt`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1923
+assert_return(
+  () => invoke($0, `gt`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:1924
+assert_return(
+  () => invoke($0, `gt`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1925
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1926
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1927
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1928
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1929
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1930
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1931
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1932
+assert_return(
+  () => invoke($0, `gt`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1933
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1934
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1935
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1936
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1937
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1938
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1939
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1940
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1941
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1942
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1943
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1944
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1945
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1946
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1947
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1948
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1949
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1950
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1951
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1952
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1953
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1954
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1955
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1956
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1957
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1958
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1959
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1960
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1961
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1962
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1963
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1964
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1965
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1966
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1967
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1968
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1969
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1970
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1971
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1972
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1973
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1974
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1975
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1976
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1977
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1978
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1979
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1980
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1981
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1982
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1983
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1984
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1985
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1986
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1987
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1988
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1989
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1990
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1991
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1992
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1993
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1994
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1995
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1996
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1997
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1998
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:1999
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2000
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2001
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2002
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2003
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2004
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2005
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2006
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2007
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2008
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2009
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2010
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2011
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2012
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2013
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2014
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2015
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2016
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2017
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2018
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2019
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2020
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2021
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2022
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2023
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2024
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2025
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2026
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2027
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2028
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2029
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2030
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2031
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2032
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2033
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -0), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2034
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -0), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2035
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 0), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2036
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 0), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2037
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2038
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2039
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2040
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2041
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2042
+assert_return(() => invoke($0, `ge`, [value("f64", -0), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2043
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2044
+assert_return(() => invoke($0, `ge`, [value("f64", 0), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2045
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2046
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2047
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2048
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2049
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2050
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2051
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2052
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2053
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2054
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2055
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2056
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2057
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2058
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2059
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2060
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2061
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2062
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2063
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2064
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2065
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2066
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2067
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2068
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2069
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2070
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2071
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2072
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2073
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2074
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2075
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2076
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2077
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2078
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2079
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2080
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2081
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2082
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2083
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2084
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2085
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2086
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2087
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2088
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2089
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2090
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2091
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2092
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2093
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2094
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2095
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2096
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2097
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2098
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2099
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2100
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2101
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2102
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2103
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2104
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2105
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2106
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2107
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2108
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2109
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2110
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2111
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2112
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2113
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2114
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2115
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2116
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2117
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2118
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2119
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2120
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2121
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2122
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2123
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2124
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2125
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2126
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2127
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2128
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2129
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2130
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2131
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2132
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2133
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2134
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2135
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2136
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2137
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2138
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2139
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2140
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2141
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2142
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2143
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2144
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2145
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2146
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2147
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2148
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2149
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2150
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2151
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2152
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2153
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2154
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2155
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 0.5), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2156
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 0.5), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2157
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2158
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2159
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2160
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2161
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2162
+assert_return(() => invoke($0, `ge`, [value("f64", -0.5), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2163
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2164
+assert_return(() => invoke($0, `ge`, [value("f64", 0.5), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2165
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2166
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2167
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2168
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2169
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2170
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2171
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2172
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 0.5),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2173
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2174
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2175
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2176
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2177
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2178
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2179
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2180
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2181
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2182
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2183
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2184
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2185
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2186
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2187
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2188
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2189
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2190
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2191
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2192
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2193
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -1), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2194
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -1), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2195
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 1), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2196
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 1), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2197
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2198
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2199
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2200
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2201
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2202
+assert_return(() => invoke($0, `ge`, [value("f64", -1), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2203
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", -Infinity)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2204
+assert_return(() => invoke($0, `ge`, [value("f64", 1), value("f64", Infinity)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2205
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2206
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2207
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2208
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2209
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2210
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2211
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2212
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 1),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2213
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", -0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2214
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", 0)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2215
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", -0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2216
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", 0)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2217
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2218
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2219
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2220
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2221
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2222
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2223
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2224
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2225
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2226
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2227
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", -0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2228
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", 0.5)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2229
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", -1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2230
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2231
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", -1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2232
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2233
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2234
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2235
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2236
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2237
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2238
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2239
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2240
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2241
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2242
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2243
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2244
+assert_return(
+  () => invoke($0, `ge`, [value("f64", 6.283185307179586), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2245
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2246
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2247
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2248
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2249
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2250
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2251
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2252
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 6.283185307179586),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2253
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2254
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2255
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2256
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2257
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2258
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2259
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2260
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2261
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2262
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2263
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2264
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2265
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2266
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2267
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2268
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2269
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2270
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2271
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2272
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2273
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2274
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2275
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2276
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2277
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2278
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2279
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2280
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2281
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2282
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2283
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2284
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2285
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2286
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2287
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2288
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2289
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2290
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2291
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2292
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2293
+assert_return(() => invoke($0, `ge`, [value("f64", -Infinity), value("f64", -0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2294
+assert_return(() => invoke($0, `ge`, [value("f64", -Infinity), value("f64", 0)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2295
+assert_return(() => invoke($0, `ge`, [value("f64", Infinity), value("f64", -0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2296
+assert_return(() => invoke($0, `ge`, [value("f64", Infinity), value("f64", 0)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2297
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2298
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2299
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2300
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2301
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2302
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2303
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2304
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2305
+assert_return(() => invoke($0, `ge`, [value("f64", -Infinity), value("f64", -0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2306
+assert_return(() => invoke($0, `ge`, [value("f64", -Infinity), value("f64", 0.5)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2307
+assert_return(() => invoke($0, `ge`, [value("f64", Infinity), value("f64", -0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2308
+assert_return(() => invoke($0, `ge`, [value("f64", Infinity), value("f64", 0.5)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2309
+assert_return(() => invoke($0, `ge`, [value("f64", -Infinity), value("f64", -1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2310
+assert_return(() => invoke($0, `ge`, [value("f64", -Infinity), value("f64", 1)]), [value("i32", 0)]);
+
+// ./test/core/f64_cmp.wast:2311
+assert_return(() => invoke($0, `ge`, [value("f64", Infinity), value("f64", -1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2312
+assert_return(() => invoke($0, `ge`, [value("f64", Infinity), value("f64", 1)]), [value("i32", 1)]);
+
+// ./test/core/f64_cmp.wast:2313
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2314
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2315
+assert_return(
+  () => invoke($0, `ge`, [value("f64", Infinity), value("f64", -6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2316
+assert_return(
+  () => invoke($0, `ge`, [value("f64", Infinity), value("f64", 6.283185307179586)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2317
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2318
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2319
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2320
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2321
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -Infinity), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2322
+assert_return(
+  () => invoke($0, `ge`, [value("f64", -Infinity), value("f64", Infinity)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2323
+assert_return(
+  () => invoke($0, `ge`, [value("f64", Infinity), value("f64", -Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2324
+assert_return(
+  () => invoke($0, `ge`, [value("f64", Infinity), value("f64", Infinity)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/f64_cmp.wast:2325
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2326
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2327
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2328
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", -Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2329
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2330
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2331
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2332
+assert_return(
+  () => invoke($0, `ge`, [
+    value("f64", Infinity),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2333
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2334
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2335
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2336
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2337
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2338
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2339
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2340
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2341
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2342
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2343
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2344
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2345
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2346
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2347
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2348
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2349
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2350
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2351
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2352
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2353
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2354
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2355
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2356
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2357
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2358
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2359
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2360
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2361
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2362
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2363
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2364
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 0.5),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2365
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2366
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2367
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2368
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2369
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2370
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2371
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2372
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 1),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2373
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2374
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2375
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2376
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2377
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2378
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2379
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2380
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 6.283185307179586),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2381
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2382
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2383
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2384
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2385
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2386
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2387
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2388
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2389
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2390
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2391
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2392
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2393
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2394
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", -Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2395
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2396
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2397
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2398
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2399
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2400
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2401
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2402
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2403
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2404
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2405
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2406
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2407
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2408
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2409
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2410
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2411
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2412
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/f64_cmp.wast:2417
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.eq (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_cmp.wast:2418
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.ge (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_cmp.wast:2419
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.gt (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_cmp.wast:2420
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.le (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_cmp.wast:2421
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.lt (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/f64_cmp.wast:2422
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64.ne (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/fac.wast.js b/js/src/jit-test/tests/wasm/spec/spec/fac.wast.js
new file mode 100644
index 0000000000..f356881230
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/fac.wast.js
@@ -0,0 +1,139 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/fac.wast
+
+// ./test/core/fac.wast:1
+let $0 = instantiate(`(module
+  ;; Recursive factorial
+  (func (export "fac-rec") (param i64) (result i64)
+    (if (result i64) (i64.eq (local.get 0) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1))))
+      )
+    )
+  )
+
+  ;; Recursive factorial named
+  (func $$fac-rec-named (export "fac-rec-named") (param $$n i64) (result i64)
+    (if (result i64) (i64.eq (local.get $$n) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get $$n)
+          (call $$fac-rec-named (i64.sub (local.get $$n) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  ;; Iterative factorial
+  (func (export "fac-iter") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (local.get 0))
+    (local.set 2 (i64.const 1))
+    (block
+      (loop
+        (if
+          (i64.eq (local.get 1) (i64.const 0))
+          (then (br 2))
+          (else
+            (local.set 2 (i64.mul (local.get 1) (local.get 2)))
+            (local.set 1 (i64.sub (local.get 1) (i64.const 1)))
+          )
+        )
+        (br 0)
+      )
+    )
+    (local.get 2)
+  )
+
+  ;; Iterative factorial named
+  (func (export "fac-iter-named") (param $$n i64) (result i64)
+    (local $$i i64)
+    (local $$res i64)
+    (local.set $$i (local.get $$n))
+    (local.set $$res (i64.const 1))
+    (block $$done
+      (loop $$loop
+        (if
+          (i64.eq (local.get $$i) (i64.const 0))
+          (then (br $$done))
+          (else
+            (local.set $$res (i64.mul (local.get $$i) (local.get $$res)))
+            (local.set $$i (i64.sub (local.get $$i) (i64.const 1)))
+          )
+        )
+        (br $$loop)
+      )
+    )
+    (local.get $$res)
+  )
+
+  ;; Optimized factorial.
+  (func (export "fac-opt") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
+      (loop
+        (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+        (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Iterative factorial without locals.
+  (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 (export "fac-ssa") (param i64) (result i64)
+    (i64.const 1) (local.get 0)
+    (loop $$l (param i64 i64) (result i64)
+      (call $$pick1) (call $$pick1) (i64.mul)
+      (call $$pick1) (i64.const 1) (i64.sub)
+      (call $$pick0) (i64.const 0) (i64.gt_u)
+      (br_if $$l)
+      (drop) (return)
+    )
+  )
+)`);
+
+// ./test/core/fac.wast:102
+assert_return(() => invoke($0, `fac-rec`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/fac.wast:103
+assert_return(() => invoke($0, `fac-iter`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/fac.wast:104
+assert_return(() => invoke($0, `fac-rec-named`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/fac.wast:105
+assert_return(() => invoke($0, `fac-iter-named`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/fac.wast:106
+assert_return(() => invoke($0, `fac-opt`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/fac.wast:107
+assert_return(() => invoke($0, `fac-ssa`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/fac.wast:109
+assert_exhaustion(() => invoke($0, `fac-rec`, [1073741824n]), `call stack exhausted`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/float_exprs.wast.js b/js/src/jit-test/tests/wasm/spec/spec/float_exprs.wast.js
new file mode 100644
index 0000000000..120b1402c4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/float_exprs.wast.js
@@ -0,0 +1,7295 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/float_exprs.wast
+
+// ./test/core/float_exprs.wast:6
+let $0 = instantiate(`(module
+  (func (export "f64.no_contraction") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.add (f64.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:11
+assert_return(
+  () => invoke($0, `f64.no_contraction`, [
+    value("f64", -0.00000000000000000000000000000015967133604096234),
+    value("f64", 87633521608271230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 42896576204898460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -13992561434270632000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:12
+assert_return(
+  () => invoke($0, `f64.no_contraction`, [
+    value("f64", 8341016642481988),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003223424965918293),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023310835741659086),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000026886641288847496),
+  ],
+);
+
+// ./test/core/float_exprs.wast:13
+assert_return(
+  () => invoke($0, `f64.no_contraction`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030119045290520013),
+    value("f64", 52699336439236750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000000000000000000006654454781339856),
+  ]),
+  [value("f64", -0.0000000000000000015872537009936566)],
+);
+
+// ./test/core/float_exprs.wast:14
+assert_return(
+  () => invoke($0, `f64.no_contraction`, [
+    value("f64", 0.0000000000000000000031413936116780743),
+    value("f64", -0.0000000000000000000000000000007262766035707377),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000004619684894228461),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000228152068276836),
+  ],
+);
+
+// ./test/core/float_exprs.wast:15
+assert_return(
+  () => invoke($0, `f64.no_contraction`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016080464217402378),
+    value("f64", -382103410226833000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000010541980504151345),
+  ]),
+  [value("f64", 0.00006144400215510552)],
+);
+
+// ./test/core/float_exprs.wast:19
+let $1 = instantiate(`(module
+  (func (export "f32.no_fma") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.add (f32.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+  (func (export "f64.no_fma") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.add (f64.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:26
+assert_return(
+  () => invoke($1, `f32.no_fma`, [
+    value("f32", 35184304000000000000000000000000000000),
+    value("f32", 0.00000021584361),
+    value("f32", 259340640000000000000000000000000),
+  ]),
+  [value("f32", 266934960000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:27
+assert_return(
+  () => invoke($1, `f32.no_fma`, [
+    value("f32", 0.0000000071753243),
+    value("f32", -0.000000000000001225534),
+    value("f32", 0.0000000000000000000000000041316436),
+  ]),
+  [value("f32", -0.0000000000000000000000087894724)],
+);
+
+// ./test/core/float_exprs.wast:28
+assert_return(
+  () => invoke($1, `f32.no_fma`, [
+    value("f32", 231063440000),
+    value("f32", 0.00020773262),
+    value("f32", 1797.6421),
+  ]),
+  [value("f32", 48001210)],
+);
+
+// ./test/core/float_exprs.wast:29
+assert_return(
+  () => invoke($1, `f32.no_fma`, [
+    value("f32", 0.0045542703),
+    value("f32", -7265493.5),
+    value("f32", -2.3964283),
+  ]),
+  [value("f32", -33091.414)],
+);
+
+// ./test/core/float_exprs.wast:30
+assert_return(
+  () => invoke($1, `f32.no_fma`, [
+    value("f32", 98881730000000000000000000000000000000),
+    value("f32", -0.0000000000000000000008570631),
+    value("f32", -21579143000),
+  ]),
+  [value("f32", -84747910000000000)],
+);
+
+// ./test/core/float_exprs.wast:31
+assert_return(
+  () => invoke($1, `f64.no_fma`, [
+    value("f64", 789084284375179200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 4215020052117360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1336601081131744700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 1989405000320312800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:32
+assert_return(
+  () => invoke($1, `f64.no_fma`, [
+    value("f64", 5586822348009285500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000000000007397302005677334),
+    value("f64", 36567834172040920000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 4132741216029240700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:33
+assert_return(
+  () => invoke($1, `f64.no_fma`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014260477822274587),
+    value("f64", -31087632036599860000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 343269235523777630000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -4433244872049653000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:34
+assert_return(
+  () => invoke($1, `f64.no_fma`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000809034701735478),
+    value("f64", -24874417850667450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 49484765138510810),
+  ]),
+  [value("f64", 250727437405094720)],
+);
+
+// ./test/core/float_exprs.wast:35
+assert_return(
+  () => invoke($1, `f64.no_fma`, [
+    value("f64", 6723256985364377),
+    value("f64", 285456566692879460000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -5593839470050757000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 1919197856036028600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:40
+let $2 = instantiate(`(module
+  (func (export "f32.no_fold_add_zero") (param $$x f32) (result f32)
+    (f32.add (local.get $$x) (f32.const 0.0)))
+  (func (export "f64.no_fold_add_zero") (param $$x f64) (result f64)
+    (f64.add (local.get $$x) (f64.const 0.0)))
+)`);
+
+// ./test/core/float_exprs.wast:47
+assert_return(() => invoke($2, `f32.no_fold_add_zero`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:48
+assert_return(() => invoke($2, `f64.no_fold_add_zero`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:49
+assert_return(
+  () => invoke($2, `f32.no_fold_add_zero`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:50
+assert_return(
+  () => invoke($2, `f64.no_fold_add_zero`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:54
+let $3 = instantiate(`(module
+  (func (export "f32.no_fold_zero_sub") (param $$x f32) (result f32)
+    (f32.sub (f32.const 0.0) (local.get $$x)))
+  (func (export "f64.no_fold_zero_sub") (param $$x f64) (result f64)
+    (f64.sub (f64.const 0.0) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:61
+assert_return(() => invoke($3, `f32.no_fold_zero_sub`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:62
+assert_return(() => invoke($3, `f64.no_fold_zero_sub`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:63
+assert_return(
+  () => invoke($3, `f32.no_fold_zero_sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:64
+assert_return(
+  () => invoke($3, `f64.no_fold_zero_sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:68
+let $4 = instantiate(`(module
+  (func (export "f32.no_fold_sub_zero") (param $$x f32) (result f32)
+    (f32.sub (local.get $$x) (f32.const 0.0)))
+  (func (export "f64.no_fold_sub_zero") (param $$x f64) (result f64)
+    (f64.sub (local.get $$x) (f64.const 0.0)))
+)`);
+
+// ./test/core/float_exprs.wast:75
+assert_return(
+  () => invoke($4, `f32.no_fold_sub_zero`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:76
+assert_return(
+  () => invoke($4, `f64.no_fold_sub_zero`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:80
+let $5 = instantiate(`(module
+  (func (export "f32.no_fold_mul_zero") (param $$x f32) (result f32)
+    (f32.mul (local.get $$x) (f32.const 0.0)))
+  (func (export "f64.no_fold_mul_zero") (param $$x f64) (result f64)
+    (f64.mul (local.get $$x) (f64.const 0.0)))
+)`);
+
+// ./test/core/float_exprs.wast:87
+assert_return(() => invoke($5, `f32.no_fold_mul_zero`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:88
+assert_return(() => invoke($5, `f32.no_fold_mul_zero`, [value("f32", -1)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:89
+assert_return(() => invoke($5, `f32.no_fold_mul_zero`, [value("f32", -2)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:90
+assert_return(
+  () => invoke($5, `f32.no_fold_mul_zero`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:91
+assert_return(() => invoke($5, `f64.no_fold_mul_zero`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:92
+assert_return(() => invoke($5, `f64.no_fold_mul_zero`, [value("f64", -1)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:93
+assert_return(() => invoke($5, `f64.no_fold_mul_zero`, [value("f64", -2)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:94
+assert_return(
+  () => invoke($5, `f64.no_fold_mul_zero`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:99
+let $6 = instantiate(`(module
+  (func (export "f32.no_fold_mul_one") (param $$x f32) (result f32)
+    (f32.mul (local.get $$x) (f32.const 1.0)))
+  (func (export "f64.no_fold_mul_one") (param $$x f64) (result f64)
+    (f64.mul (local.get $$x) (f64.const 1.0)))
+)`);
+
+// ./test/core/float_exprs.wast:106
+assert_return(
+  () => invoke($6, `f32.no_fold_mul_one`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:107
+assert_return(
+  () => invoke($6, `f64.no_fold_mul_one`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:111
+let $7 = instantiate(`(module
+  (func (export "f32.no_fold_zero_div") (param $$x f32) (result f32)
+    (f32.div (f32.const 0.0) (local.get $$x)))
+  (func (export "f64.no_fold_zero_div") (param $$x f64) (result f64)
+    (f64.div (f64.const 0.0) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:118
+assert_return(() => invoke($7, `f32.no_fold_zero_div`, [value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:119
+assert_return(() => invoke($7, `f32.no_fold_zero_div`, [value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:120
+assert_return(
+  () => invoke($7, `f32.no_fold_zero_div`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:121
+assert_return(
+  () => invoke($7, `f32.no_fold_zero_div`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:122
+assert_return(() => invoke($7, `f64.no_fold_zero_div`, [value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:123
+assert_return(() => invoke($7, `f64.no_fold_zero_div`, [value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:124
+assert_return(
+  () => invoke($7, `f64.no_fold_zero_div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:125
+assert_return(
+  () => invoke($7, `f64.no_fold_zero_div`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:129
+let $8 = instantiate(`(module
+  (func (export "f32.no_fold_div_one") (param $$x f32) (result f32)
+    (f32.div (local.get $$x) (f32.const 1.0)))
+  (func (export "f64.no_fold_div_one") (param $$x f64) (result f64)
+    (f64.div (local.get $$x) (f64.const 1.0)))
+)`);
+
+// ./test/core/float_exprs.wast:136
+assert_return(
+  () => invoke($8, `f32.no_fold_div_one`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:137
+assert_return(
+  () => invoke($8, `f64.no_fold_div_one`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:141
+let $9 = instantiate(`(module
+  (func (export "f32.no_fold_div_neg1") (param $$x f32) (result f32)
+    (f32.div (local.get $$x) (f32.const -1.0)))
+  (func (export "f64.no_fold_div_neg1") (param $$x f64) (result f64)
+    (f64.div (local.get $$x) (f64.const -1.0)))
+)`);
+
+// ./test/core/float_exprs.wast:148
+assert_return(
+  () => invoke($9, `f32.no_fold_div_neg1`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:149
+assert_return(
+  () => invoke($9, `f64.no_fold_div_neg1`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:153
+let $10 = instantiate(`(module
+  (func (export "f32.no_fold_neg0_sub") (param $$x f32) (result f32)
+    (f32.sub (f32.const -0.0) (local.get $$x)))
+  (func (export "f64.no_fold_neg0_sub") (param $$x f64) (result f64)
+    (f64.sub (f64.const -0.0) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:160
+assert_return(
+  () => invoke($10, `f32.no_fold_neg0_sub`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:161
+assert_return(
+  () => invoke($10, `f64.no_fold_neg0_sub`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:165
+let $11 = instantiate(`(module
+  (func (export "f32.no_fold_neg1_mul") (param $$x f32) (result f32)
+    (f32.mul (f32.const -1.0) (local.get $$x)))
+  (func (export "f64.no_fold_neg1_mul") (param $$x f64) (result f64)
+    (f64.mul (f64.const -1.0) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:172
+assert_return(
+  () => invoke($11, `f32.no_fold_neg1_mul`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:173
+assert_return(
+  () => invoke($11, `f64.no_fold_neg1_mul`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:177
+let $12 = instantiate(`(module
+  (func (export "f32.no_fold_eq_self") (param $$x f32) (result i32)
+    (f32.eq (local.get $$x) (local.get $$x)))
+  (func (export "f64.no_fold_eq_self") (param $$x f64) (result i32)
+    (f64.eq (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:184
+assert_return(
+  () => invoke($12, `f32.no_fold_eq_self`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:185
+assert_return(
+  () => invoke($12, `f64.no_fold_eq_self`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:189
+let $13 = instantiate(`(module
+  (func (export "f32.no_fold_ne_self") (param $$x f32) (result i32)
+    (f32.ne (local.get $$x) (local.get $$x)))
+  (func (export "f64.no_fold_ne_self") (param $$x f64) (result i32)
+    (f64.ne (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:196
+assert_return(
+  () => invoke($13, `f32.no_fold_ne_self`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:197
+assert_return(
+  () => invoke($13, `f64.no_fold_ne_self`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:201
+let $14 = instantiate(`(module
+  (func (export "f32.no_fold_sub_self") (param $$x f32) (result f32)
+    (f32.sub (local.get $$x) (local.get $$x)))
+  (func (export "f64.no_fold_sub_self") (param $$x f64) (result f64)
+    (f64.sub (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:208
+assert_return(() => invoke($14, `f32.no_fold_sub_self`, [value("f32", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:209
+assert_return(
+  () => invoke($14, `f32.no_fold_sub_self`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:210
+assert_return(() => invoke($14, `f64.no_fold_sub_self`, [value("f64", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:211
+assert_return(
+  () => invoke($14, `f64.no_fold_sub_self`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:215
+let $15 = instantiate(`(module
+  (func (export "f32.no_fold_div_self") (param $$x f32) (result f32)
+    (f32.div (local.get $$x) (local.get $$x)))
+  (func (export "f64.no_fold_div_self") (param $$x f64) (result f64)
+    (f64.div (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:222
+assert_return(() => invoke($15, `f32.no_fold_div_self`, [value("f32", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:223
+assert_return(
+  () => invoke($15, `f32.no_fold_div_self`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:224
+assert_return(() => invoke($15, `f32.no_fold_div_self`, [value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:225
+assert_return(() => invoke($15, `f32.no_fold_div_self`, [value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:226
+assert_return(() => invoke($15, `f64.no_fold_div_self`, [value("f64", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:227
+assert_return(
+  () => invoke($15, `f64.no_fold_div_self`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:228
+assert_return(() => invoke($15, `f64.no_fold_div_self`, [value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:229
+assert_return(() => invoke($15, `f64.no_fold_div_self`, [value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:233
+let $16 = instantiate(`(module
+  (func (export "f32.no_fold_div_3") (param $$x f32) (result f32)
+    (f32.div (local.get $$x) (f32.const 3.0)))
+  (func (export "f64.no_fold_div_3") (param $$x f64) (result f64)
+    (f64.div (local.get $$x) (f64.const 3.0)))
+)`);
+
+// ./test/core/float_exprs.wast:240
+assert_return(
+  () => invoke($16, `f32.no_fold_div_3`, [value("f32", -1361679000000000)]),
+  [value("f32", -453892980000000)],
+);
+
+// ./test/core/float_exprs.wast:241
+assert_return(
+  () => invoke($16, `f32.no_fold_div_3`, [value("f32", -18736880000000000000000000000)]),
+  [value("f32", -6245626600000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:242
+assert_return(
+  () => invoke($16, `f32.no_fold_div_3`, [
+    value("f32", -0.00000000000000000000000012045131),
+  ]),
+  [value("f32", -0.000000000000000000000000040150435)],
+);
+
+// ./test/core/float_exprs.wast:243
+assert_return(
+  () => invoke($16, `f32.no_fold_div_3`, [
+    value("f32", -0.00000000000000000000000000000000000005281346),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000017604486)],
+);
+
+// ./test/core/float_exprs.wast:244
+assert_return(
+  () => invoke($16, `f32.no_fold_div_3`, [value("f32", -0.000000000000000025495563)]),
+  [value("f32", -0.000000000000000008498521)],
+);
+
+// ./test/core/float_exprs.wast:245
+assert_return(
+  () => invoke($16, `f64.no_fold_div_3`, [
+    value("f64", -29563579573969634000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -9854526524656545000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:246
+assert_return(
+  () => invoke($16, `f64.no_fold_div_3`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000009291150921449772),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000003097050307149924),
+  ],
+);
+
+// ./test/core/float_exprs.wast:247
+assert_return(
+  () => invoke($16, `f64.no_fold_div_3`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013808061543557006),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004602687181185669),
+  ],
+);
+
+// ./test/core/float_exprs.wast:248
+assert_return(
+  () => invoke($16, `f64.no_fold_div_3`, [
+    value("f64", -1378076163468349000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -459358721156116300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:249
+assert_return(
+  () => invoke($16, `f64.no_fold_div_3`, [
+    value("f64", 86324008088313660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 28774669362771220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:253
+let $17 = instantiate(`(module
+  (func (export "f32.no_factor") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.add (f32.mul (local.get $$x) (local.get $$z)) (f32.mul (local.get $$y) (local.get $$z))))
+  (func (export "f64.no_factor") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.add (f64.mul (local.get $$x) (local.get $$z)) (f64.mul (local.get $$y) (local.get $$z))))
+)`);
+
+// ./test/core/float_exprs.wast:260
+assert_return(
+  () => invoke($17, `f32.no_factor`, [
+    value("f32", -1435111700000),
+    value("f32", -853617640000000),
+    value("f32", 1113849300000000000),
+  ]),
+  [value("f32", -952399900000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:261
+assert_return(
+  () => invoke($17, `f32.no_factor`, [
+    value("f32", -0.026666632),
+    value("f32", 0.048412822),
+    value("f32", -0.002813697),
+  ]),
+  [value("f32", -0.0000611872)],
+);
+
+// ./test/core/float_exprs.wast:262
+assert_return(
+  () => invoke($17, `f32.no_factor`, [
+    value("f32", -0.00000000000046619777),
+    value("f32", 0.00000000000000000010478377),
+    value("f32", 14469202000000000000000000000000000000),
+  ]),
+  [value("f32", -6745508000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:263
+assert_return(
+  () => invoke($17, `f32.no_factor`, [
+    value("f32", -0.00000000000000000010689046),
+    value("f32", 0.00000000000000000000000010694433),
+    value("f32", 568307000000000000000000000000000000),
+  ]),
+  [value("f32", -60746540000000000)],
+);
+
+// ./test/core/float_exprs.wast:264
+assert_return(
+  () => invoke($17, `f32.no_factor`, [
+    value("f32", -0.000000000000000000000000063545994),
+    value("f32", 0.0000000000000000000007524625),
+    value("f32", 1626770.3),
+  ]),
+  [value("f32", 0.0000000000000012239803)],
+);
+
+// ./test/core/float_exprs.wast:265
+assert_return(
+  () => invoke($17, `f64.no_factor`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028390554709988774),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001473981250649641),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000029001229846550766),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008233610026197336),
+  ],
+);
+
+// ./test/core/float_exprs.wast:266
+assert_return(
+  () => invoke($17, `f64.no_factor`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006461015505916123),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023923242802975938),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015300738798561604),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:267
+assert_return(
+  () => invoke($17, `f64.no_factor`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002939056292080733),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356),
+    value("f64", -2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 538892923853642600000000000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:268
+assert_return(
+  () => invoke($17, `f64.no_factor`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000017785466771708878),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000009328516775403213),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000012121009044876735),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001130710359943689),
+  ],
+);
+
+// ./test/core/float_exprs.wast:269
+assert_return(
+  () => invoke($17, `f64.no_factor`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015194859063177362),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065),
+    value("f64", -1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.0000000000000000000000000015337619131701908)],
+);
+
+// ./test/core/float_exprs.wast:273
+let $18 = instantiate(`(module
+  (func (export "f32.no_distribute") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.mul (f32.add (local.get $$x) (local.get $$y)) (local.get $$z)))
+  (func (export "f64.no_distribute") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.mul (f64.add (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:280
+assert_return(
+  () => invoke($18, `f32.no_distribute`, [
+    value("f32", -1435111700000),
+    value("f32", -853617640000000),
+    value("f32", 1113849300000000000),
+  ]),
+  [value("f32", -952400000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:281
+assert_return(
+  () => invoke($18, `f32.no_distribute`, [
+    value("f32", -0.026666632),
+    value("f32", 0.048412822),
+    value("f32", -0.002813697),
+  ]),
+  [value("f32", -0.000061187195)],
+);
+
+// ./test/core/float_exprs.wast:282
+assert_return(
+  () => invoke($18, `f32.no_distribute`, [
+    value("f32", -0.00000000000046619777),
+    value("f32", 0.00000000000000000010478377),
+    value("f32", 14469202000000000000000000000000000000),
+  ]),
+  [value("f32", -6745508500000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:283
+assert_return(
+  () => invoke($18, `f32.no_distribute`, [
+    value("f32", -0.00000000000000000010689046),
+    value("f32", 0.00000000000000000000000010694433),
+    value("f32", 568307000000000000000000000000000000),
+  ]),
+  [value("f32", -60746536000000000)],
+);
+
+// ./test/core/float_exprs.wast:284
+assert_return(
+  () => invoke($18, `f32.no_distribute`, [
+    value("f32", -0.000000000000000000000000063545994),
+    value("f32", 0.0000000000000000000007524625),
+    value("f32", 1626770.3),
+  ]),
+  [value("f32", 0.0000000000000012239802)],
+);
+
+// ./test/core/float_exprs.wast:285
+assert_return(
+  () => invoke($18, `f64.no_distribute`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028390554709988774),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001473981250649641),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000029001229846550766),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008233610026197337),
+  ],
+);
+
+// ./test/core/float_exprs.wast:286
+assert_return(
+  () => invoke($18, `f64.no_distribute`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006461015505916123),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023923242802975938),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015300738798561604),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:287
+assert_return(
+  () => invoke($18, `f64.no_distribute`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002939056292080733),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000002146156743463356),
+    value("f64", -2510967223130241600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 538892923853642500000000000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:288
+assert_return(
+  () => invoke($18, `f64.no_distribute`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000017785466771708878),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000009328516775403213),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000012121009044876735),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011307103599436889),
+  ],
+);
+
+// ./test/core/float_exprs.wast:289
+assert_return(
+  () => invoke($18, `f64.no_distribute`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015194859063177362),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000883589921438065),
+    value("f64", -1735830019469195800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.0000000000000000000000000015337619131701907)],
+);
+
+// ./test/core/float_exprs.wast:293
+let $19 = instantiate(`(module
+  (func (export "f32.no_regroup_div_mul") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.mul (local.get $$x) (f32.div (local.get $$y) (local.get $$z))))
+  (func (export "f64.no_regroup_div_mul") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.mul (local.get $$x) (f64.div (local.get $$y) (local.get $$z))))
+)`);
+
+// ./test/core/float_exprs.wast:300
+assert_return(
+  () => invoke($19, `f32.no_regroup_div_mul`, [
+    value("f32", -0.00000000000000000000000000000000002831349),
+    value("f32", -0.00000000000000000007270787),
+    value("f32", 0.000000000000000000000000000000000016406605),
+  ]),
+  [value("f32", 0.00000000000000000012547468)],
+);
+
+// ./test/core/float_exprs.wast:301
+assert_return(
+  () => invoke($19, `f32.no_regroup_div_mul`, [
+    value("f32", -3145897700000000000000000000),
+    value("f32", -0.000000000000000000000000000000000040864003),
+    value("f32", -9245928300000000000000),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:302
+assert_return(
+  () => invoke($19, `f32.no_regroup_div_mul`, [
+    value("f32", -93157.43),
+    value("f32", -0.00000081292654),
+    value("f32", -0.00000000000000000000000000000000000015469397),
+  ]),
+  [value("f32", -489548120000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:303
+assert_return(
+  () => invoke($19, `f32.no_regroup_div_mul`, [
+    value("f32", -0.00000000000000000000000000008899643),
+    value("f32", 17887725000000000000000),
+    value("f32", 514680230000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000003093073)],
+);
+
+// ./test/core/float_exprs.wast:304
+assert_return(
+  () => invoke($19, `f32.no_regroup_div_mul`, [
+    value("f32", 9222036000000000000000000000000000),
+    value("f32", 33330492),
+    value("f32", -3253108800000000000000),
+  ]),
+  [value("f32", -94486550000000000000)],
+);
+
+// ./test/core/float_exprs.wast:305
+assert_return(
+  () => invoke($19, `f64.no_regroup_div_mul`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005698811412550059),
+    value("f64", -0.0000000000000000000000000000000000018313439132919336),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098),
+  ]),
+  [value("f64", -1093596114413331000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:306
+assert_return(
+  () => invoke($19, `f64.no_regroup_div_mul`, [
+    value("f64", 357289288425507550000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003952760844538651),
+    value("f64", -1450781241254900800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:307
+assert_return(
+  () => invoke($19, `f64.no_regroup_div_mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009124278383497107),
+    value("f64", 55561345277147970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025090826940306507),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:308
+assert_return(
+  () => invoke($19, `f64.no_regroup_div_mul`, [
+    value("f64", -4492093000352015000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -12087878984017852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -596613380626062300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -91013507803376260000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:309
+assert_return(
+  () => invoke($19, `f64.no_regroup_div_mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007470269158630455),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007568026329781282),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001055389683973521),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005356807494101561),
+  ],
+);
+
+// ./test/core/float_exprs.wast:313
+let $20 = instantiate(`(module
+  (func (export "f32.no_regroup_mul_div") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.div (f32.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+  (func (export "f64.no_regroup_mul_div") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.div (f64.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:320
+assert_return(
+  () => invoke($20, `f32.no_regroup_mul_div`, [
+    value("f32", -0.00000000000000000000000000000000002831349),
+    value("f32", -0.00000000000000000007270787),
+    value("f32", 0.000000000000000000000000000000000016406605),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:321
+assert_return(
+  () => invoke($20, `f32.no_regroup_mul_div`, [
+    value("f32", -3145897700000000000000000000),
+    value("f32", -0.000000000000000000000000000000000040864003),
+    value("f32", -9245928300000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000013903848)],
+);
+
+// ./test/core/float_exprs.wast:322
+assert_return(
+  () => invoke($20, `f32.no_regroup_mul_div`, [
+    value("f32", -93157.43),
+    value("f32", -0.00000081292654),
+    value("f32", -0.00000000000000000000000000000000000015469397),
+  ]),
+  [value("f32", -489548160000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:323
+assert_return(
+  () => invoke($20, `f32.no_regroup_mul_div`, [
+    value("f32", -0.00000000000000000000000000008899643),
+    value("f32", 17887725000000000000000),
+    value("f32", 514680230000000000000),
+  ]),
+  [value("f32", -0.0000000000000000000000000030930732)],
+);
+
+// ./test/core/float_exprs.wast:324
+assert_return(
+  () => invoke($20, `f32.no_regroup_mul_div`, [
+    value("f32", 9222036000000000000000000000000000),
+    value("f32", 33330492),
+    value("f32", -3253108800000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:325
+assert_return(
+  () => invoke($20, `f64.no_regroup_mul_div`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005698811412550059),
+    value("f64", -0.0000000000000000000000000000000000018313439132919336),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009543270551003098),
+  ]),
+  [value("f64", -1093596114413331100000000000000)],
+);
+
+// ./test/core/float_exprs.wast:326
+assert_return(
+  () => invoke($20, `f64.no_regroup_mul_div`, [
+    value("f64", 357289288425507550000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003952760844538651),
+    value("f64", -1450781241254900800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009734611044734945),
+  ],
+);
+
+// ./test/core/float_exprs.wast:327
+assert_return(
+  () => invoke($20, `f64.no_regroup_mul_div`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009124278383497107),
+    value("f64", 55561345277147970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025090826940306507),
+  ]),
+  [
+    value("f64", 20204881364667663000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:328
+assert_return(
+  () => invoke($20, `f64.no_regroup_mul_div`, [
+    value("f64", -4492093000352015000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -12087878984017852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -596613380626062300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:329
+assert_return(
+  () => invoke($20, `f64.no_regroup_mul_div`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007470269158630455),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007568026329781282),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001055389683973521),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:333
+let $21 = instantiate(`(module
+  (func (export "f32.no_reassociate_add") (param $$x f32) (param $$y f32) (param $$z f32) (param $$w f32) (result f32)
+    (f32.add (f32.add (f32.add (local.get $$x) (local.get $$y)) (local.get $$z)) (local.get $$w)))
+  (func (export "f64.no_reassociate_add") (param $$x f64) (param $$y f64) (param $$z f64) (param $$w f64) (result f64)
+    (f64.add (f64.add (f64.add (local.get $$x) (local.get $$y)) (local.get $$z)) (local.get $$w)))
+)`);
+
+// ./test/core/float_exprs.wast:340
+assert_return(
+  () => invoke($21, `f32.no_reassociate_add`, [
+    value("f32", -24154321000000),
+    value("f32", 26125812000),
+    value("f32", -238608080000000),
+    value("f32", -2478953500000),
+  ]),
+  [value("f32", -265215220000000)],
+);
+
+// ./test/core/float_exprs.wast:341
+assert_return(
+  () => invoke($21, `f32.no_reassociate_add`, [
+    value("f32", 0.0036181053),
+    value("f32", -0.00985944),
+    value("f32", 0.063375376),
+    value("f32", -0.011150199),
+  ]),
+  [value("f32", 0.04598384)],
+);
+
+// ./test/core/float_exprs.wast:342
+assert_return(
+  () => invoke($21, `f32.no_reassociate_add`, [
+    value("f32", -34206968000),
+    value("f32", -3770877200000),
+    value("f32", 30868425000000),
+    value("f32", 421132080000),
+  ]),
+  [value("f32", 27484470000000)],
+);
+
+// ./test/core/float_exprs.wast:343
+assert_return(
+  () => invoke($21, `f32.no_reassociate_add`, [
+    value("f32", 153506400000000),
+    value("f32", 925114700000000),
+    value("f32", -36021854000),
+    value("f32", 2450846000000000),
+  ]),
+  [value("f32", 3529431000000000)],
+);
+
+// ./test/core/float_exprs.wast:344
+assert_return(
+  () => invoke($21, `f32.no_reassociate_add`, [
+    value("f32", 470600300000000000000000000000000),
+    value("f32", -396552040000000000000000000000000),
+    value("f32", 48066940000000000000000000000000),
+    value("f32", -35644073000000000000000000000),
+  ]),
+  [value("f32", 122079560000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:345
+assert_return(
+  () => invoke($21, `f64.no_reassociate_add`, [
+    value("f64", -20704652927717020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1594689704376369700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 451106636559416130000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -1374333509186863300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -921652887575998600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:346
+assert_return(
+  () => invoke($21, `f64.no_reassociate_add`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003485747658213531),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031210957391311754),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000683008546431621),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002617177347131095),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022324206697150536),
+  ],
+);
+
+// ./test/core/float_exprs.wast:347
+assert_return(
+  () => invoke($21, `f64.no_reassociate_add`, [
+    value("f64", -5412584921122726300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 597603656170379500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -355830077793396300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 373627259957625440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -5768414998318146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:348
+assert_return(
+  () => invoke($21, `f64.no_reassociate_add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006469047714189599),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064286584974746),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000021277698072285604),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000008768287273189493),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000006640517465960996),
+  ],
+);
+
+// ./test/core/float_exprs.wast:349
+assert_return(
+  () => invoke($21, `f64.no_reassociate_add`, [
+    value("f64", -16422137086414828000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -88032137939790710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 449957059782857850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -114091267166274390000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 319443655442136560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:353
+let $22 = instantiate(`(module
+  (func (export "f32.no_reassociate_mul") (param $$x f32) (param $$y f32) (param $$z f32) (param $$w f32) (result f32)
+    (f32.mul (f32.mul (f32.mul (local.get $$x) (local.get $$y)) (local.get $$z)) (local.get $$w)))
+  (func (export "f64.no_reassociate_mul") (param $$x f64) (param $$y f64) (param $$z f64) (param $$w f64) (result f64)
+    (f64.mul (f64.mul (f64.mul (local.get $$x) (local.get $$y)) (local.get $$z)) (local.get $$w)))
+)`);
+
+// ./test/core/float_exprs.wast:360
+assert_return(
+  () => invoke($22, `f32.no_reassociate_mul`, [
+    value("f32", 0.00000000000000000000000000000000001904515),
+    value("f32", 0.00000000022548861),
+    value("f32", -6964322000000000000000000000000),
+    value("f32", 0.000000000000000026902832),
+  ]),
+  [value("f32", -0.00000000000000000000000000000078764173)],
+);
+
+// ./test/core/float_exprs.wast:361
+assert_return(
+  () => invoke($22, `f32.no_reassociate_mul`, [
+    value("f32", 0.000000000000000018733125),
+    value("f32", -7565904000000000000000000000000),
+    value("f32", -0.000000000000000000000000000000000000030807684),
+    value("f32", -1592759200000000000000),
+  ]),
+  [value("f32", -0.0069547286)],
+);
+
+// ./test/core/float_exprs.wast:362
+assert_return(
+  () => invoke($22, `f32.no_reassociate_mul`, [
+    value("f32", 0.0000000000000050355575),
+    value("f32", -56466884000000000),
+    value("f32", -0.0000000000011740512),
+    value("f32", 84984730000000000000000),
+  ]),
+  [value("f32", 28370654000000)],
+);
+
+// ./test/core/float_exprs.wast:363
+assert_return(
+  () => invoke($22, `f32.no_reassociate_mul`, [
+    value("f32", 0.000000000000000000000000000000046394946),
+    value("f32", 254449360000000000000000),
+    value("f32", -72460980000000000),
+    value("f32", -962511040000000000),
+  ]),
+  [value("f32", 823345100000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:364
+assert_return(
+  () => invoke($22, `f32.no_reassociate_mul`, [
+    value("f32", -0.0000000000000000000000000000019420536),
+    value("f32", 0.0000000000000023200355),
+    value("f32", -9.772748),
+    value("f32", 864066000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000035113616)],
+);
+
+// ./test/core/float_exprs.wast:365
+assert_return(
+  () => invoke($22, `f64.no_reassociate_mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003109868654414946),
+    value("f64", -20713190487745434000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007162612845524978),
+    value("f64", -88478253295969090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 40822261813278614000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:366
+assert_return(
+  () => invoke($22, `f64.no_reassociate_mul`, [
+    value("f64", 60442716412956810000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006700545015107397),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031469664275798185),
+    value("f64", -6401677295640561500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008159057447560471),
+  ],
+);
+
+// ./test/core/float_exprs.wast:367
+assert_return(
+  () => invoke($22, `f64.no_reassociate_mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002216807720454268),
+    value("f64", -1802234186536721600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007500283778521931),
+    value("f64", -414412152433956900000000000),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001241793627299937),
+  ],
+);
+
+// ./test/core/float_exprs.wast:368
+assert_return(
+  () => invoke($22, `f64.no_reassociate_mul`, [
+    value("f64", 24318065966298720000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006508014075793436),
+    value("f64", 17596421287233897000000000000000000000000000000000000000000000000000),
+    value("f64", -0.0000001416141401305358),
+  ]),
+  [
+    value("f64", -3943741918531223000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:369
+assert_return(
+  () => invoke($22, `f64.no_reassociate_mul`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000003849767156964772),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000070008754943224875),
+    value("f64", -2536887825218386500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006101114518858449),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004171548126376117),
+  ],
+);
+
+// ./test/core/float_exprs.wast:373
+let $23 = instantiate(`(module
+  (func (export "f32.no_fold_div_0") (param $$x f32) (result f32)
+    (f32.div (local.get $$x) (f32.const 0.0)))
+  (func (export "f64.no_fold_div_0") (param $$x f64) (result f64)
+    (f64.div (local.get $$x) (f64.const 0.0)))
+)`);
+
+// ./test/core/float_exprs.wast:380
+assert_return(() => invoke($23, `f32.no_fold_div_0`, [value("f32", 1)]), [value("f32", Infinity)]);
+
+// ./test/core/float_exprs.wast:381
+assert_return(() => invoke($23, `f32.no_fold_div_0`, [value("f32", -1)]), [value("f32", -Infinity)]);
+
+// ./test/core/float_exprs.wast:382
+assert_return(
+  () => invoke($23, `f32.no_fold_div_0`, [value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:383
+assert_return(
+  () => invoke($23, `f32.no_fold_div_0`, [value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:384
+assert_return(() => invoke($23, `f32.no_fold_div_0`, [value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:385
+assert_return(() => invoke($23, `f32.no_fold_div_0`, [value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:386
+assert_return(
+  () => invoke($23, `f32.no_fold_div_0`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:387
+assert_return(
+  () => invoke($23, `f32.no_fold_div_0`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:388
+assert_return(() => invoke($23, `f64.no_fold_div_0`, [value("f64", 1)]), [value("f64", Infinity)]);
+
+// ./test/core/float_exprs.wast:389
+assert_return(() => invoke($23, `f64.no_fold_div_0`, [value("f64", -1)]), [value("f64", -Infinity)]);
+
+// ./test/core/float_exprs.wast:390
+assert_return(
+  () => invoke($23, `f64.no_fold_div_0`, [value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:391
+assert_return(
+  () => invoke($23, `f64.no_fold_div_0`, [value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:392
+assert_return(() => invoke($23, `f64.no_fold_div_0`, [value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:393
+assert_return(() => invoke($23, `f64.no_fold_div_0`, [value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:394
+assert_return(
+  () => invoke($23, `f64.no_fold_div_0`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:395
+assert_return(
+  () => invoke($23, `f64.no_fold_div_0`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:399
+let $24 = instantiate(`(module
+  (func (export "f32.no_fold_div_neg0") (param $$x f32) (result f32)
+    (f32.div (local.get $$x) (f32.const -0.0)))
+  (func (export "f64.no_fold_div_neg0") (param $$x f64) (result f64)
+    (f64.div (local.get $$x) (f64.const -0.0)))
+)`);
+
+// ./test/core/float_exprs.wast:406
+assert_return(() => invoke($24, `f32.no_fold_div_neg0`, [value("f32", 1)]), [value("f32", -Infinity)]);
+
+// ./test/core/float_exprs.wast:407
+assert_return(() => invoke($24, `f32.no_fold_div_neg0`, [value("f32", -1)]), [value("f32", Infinity)]);
+
+// ./test/core/float_exprs.wast:408
+assert_return(
+  () => invoke($24, `f32.no_fold_div_neg0`, [value("f32", Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:409
+assert_return(
+  () => invoke($24, `f32.no_fold_div_neg0`, [value("f32", -Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:410
+assert_return(() => invoke($24, `f32.no_fold_div_neg0`, [value("f32", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:411
+assert_return(() => invoke($24, `f32.no_fold_div_neg0`, [value("f32", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:412
+assert_return(
+  () => invoke($24, `f32.no_fold_div_neg0`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:413
+assert_return(
+  () => invoke($24, `f32.no_fold_div_neg0`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:414
+assert_return(() => invoke($24, `f64.no_fold_div_neg0`, [value("f64", 1)]), [value("f64", -Infinity)]);
+
+// ./test/core/float_exprs.wast:415
+assert_return(() => invoke($24, `f64.no_fold_div_neg0`, [value("f64", -1)]), [value("f64", Infinity)]);
+
+// ./test/core/float_exprs.wast:416
+assert_return(
+  () => invoke($24, `f64.no_fold_div_neg0`, [value("f64", Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:417
+assert_return(
+  () => invoke($24, `f64.no_fold_div_neg0`, [value("f64", -Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:418
+assert_return(() => invoke($24, `f64.no_fold_div_neg0`, [value("f64", 0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:419
+assert_return(() => invoke($24, `f64.no_fold_div_neg0`, [value("f64", -0)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:420
+assert_return(
+  () => invoke($24, `f64.no_fold_div_neg0`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:421
+assert_return(
+  () => invoke($24, `f64.no_fold_div_neg0`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:425
+let $25 = instantiate(`(module
+  (func (export "f32.no_fold_to_hypot") (param $$x f32) (param $$y f32) (result f32)
+    (f32.sqrt (f32.add (f32.mul (local.get $$x) (local.get $$x))
+                       (f32.mul (local.get $$y) (local.get $$y)))))
+  (func (export "f64.no_fold_to_hypot") (param $$x f64) (param $$y f64) (result f64)
+    (f64.sqrt (f64.add (f64.mul (local.get $$x) (local.get $$x))
+                       (f64.mul (local.get $$y) (local.get $$y)))))
+)`);
+
+// ./test/core/float_exprs.wast:434
+assert_return(
+  () => invoke($25, `f32.no_fold_to_hypot`, [
+    value("f32", 0.00000000000000000000000072854914),
+    value("f32", 0.0000000000000000000042365796),
+  ]),
+  [value("f32", 0.0000000000000000000042366535)],
+);
+
+// ./test/core/float_exprs.wast:435
+assert_return(
+  () => invoke($25, `f32.no_fold_to_hypot`, [
+    value("f32", -0.0000000000000000000007470285),
+    value("f32", -0.000000000000000000000000000000007453745),
+  ]),
+  [value("f32", 0.0000000000000000000007468044)],
+);
+
+// ./test/core/float_exprs.wast:436
+assert_return(
+  () => invoke($25, `f32.no_fold_to_hypot`, [
+    value("f32", -0.0000000000000000000000000000000000770895),
+    value("f32", -0.0000000000000000000032627214),
+  ]),
+  [value("f32", 0.0000000000000000000032627695)],
+);
+
+// ./test/core/float_exprs.wast:437
+assert_return(
+  () => invoke($25, `f32.no_fold_to_hypot`, [
+    value("f32", -35.42818),
+    value("f32", 174209.48),
+  ]),
+  [value("f32", 174209.5)],
+);
+
+// ./test/core/float_exprs.wast:438
+assert_return(
+  () => invoke($25, `f32.no_fold_to_hypot`, [
+    value("f32", 0.000000000000000000000020628143),
+    value("f32", -0.00000000000000000000046344753),
+  ]),
+  [value("f32", 0.000000000000000000000463032)],
+);
+
+// ./test/core/float_exprs.wast:439
+assert_return(
+  () => invoke($25, `f64.no_fold_to_hypot`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003863640258986321),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019133014752624014),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019120893753235554),
+  ],
+);
+
+// ./test/core/float_exprs.wast:440
+assert_return(
+  () => invoke($25, `f64.no_fold_to_hypot`, [
+    value("f64", 138561238950329770000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -2828038515930043000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 2828038519324483400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:441
+assert_return(
+  () => invoke($25, `f64.no_fold_to_hypot`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006502729096641792),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004544399933151275),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006668276248455232),
+  ],
+);
+
+// ./test/core/float_exprs.wast:442
+assert_return(
+  () => invoke($25, `f64.no_fold_to_hypot`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022340232024202604),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003435929714143315),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022340232023799234),
+  ],
+);
+
+// ./test/core/float_exprs.wast:443
+assert_return(
+  () => invoke($25, `f64.no_fold_to_hypot`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002797963998630554),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906867996862016),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019068679968620105),
+  ],
+);
+
+// ./test/core/float_exprs.wast:447
+let $26 = instantiate(`(module
+  (func (export "f32.no_approximate_reciprocal") (param $$x f32) (result f32)
+    (f32.div (f32.const 1.0) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:452
+assert_return(
+  () => invoke($26, `f32.no_approximate_reciprocal`, [value("f32", -0.0011329757)]),
+  [value("f32", -882.6315)],
+);
+
+// ./test/core/float_exprs.wast:453
+assert_return(
+  () => invoke($26, `f32.no_approximate_reciprocal`, [
+    value("f32", 323753010000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000003088774)],
+);
+
+// ./test/core/float_exprs.wast:454
+assert_return(
+  () => invoke($26, `f32.no_approximate_reciprocal`, [
+    value("f32", -0.0000000000000000000000000001272599),
+  ]),
+  [value("f32", -7857934600000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:455
+assert_return(
+  () => invoke($26, `f32.no_approximate_reciprocal`, [
+    value("f32", 103020680000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000009706789)],
+);
+
+// ./test/core/float_exprs.wast:456
+assert_return(
+  () => invoke($26, `f32.no_approximate_reciprocal`, [
+    value("f32", -0.00000000000000000000000028443763),
+  ]),
+  [value("f32", -3515709300000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:460
+let $27 = instantiate(`(module
+  (func (export "f32.no_approximate_reciprocal_sqrt") (param $$x f32) (result f32)
+    (f32.div (f32.const 1.0) (f32.sqrt (local.get $$x))))
+  (func (export "f64.no_fuse_reciprocal_sqrt") (param $$x f64) (result f64)
+    (f64.div (f64.const 1.0) (f64.sqrt (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:467
+assert_return(
+  () => invoke($27, `f32.no_approximate_reciprocal_sqrt`, [
+    value("f32", 0.00000000000016117865),
+  ]),
+  [value("f32", 2490842.5)],
+);
+
+// ./test/core/float_exprs.wast:468
+assert_return(
+  () => invoke($27, `f32.no_approximate_reciprocal_sqrt`, [value("f32", 0.0074491366)]),
+  [value("f32", 11.58636)],
+);
+
+// ./test/core/float_exprs.wast:469
+assert_return(
+  () => invoke($27, `f32.no_approximate_reciprocal_sqrt`, [
+    value("f32", 0.00000000000000000002339817),
+  ]),
+  [value("f32", 6537460000)],
+);
+
+// ./test/core/float_exprs.wast:470
+assert_return(
+  () => invoke($27, `f32.no_approximate_reciprocal_sqrt`, [
+    value("f32", 0.00000000000011123504),
+  ]),
+  [value("f32", 2998328.3)],
+);
+
+// ./test/core/float_exprs.wast:471
+assert_return(
+  () => invoke($27, `f32.no_approximate_reciprocal_sqrt`, [
+    value("f32", 0.000000000000000000000000017653063),
+  ]),
+  [value("f32", 7526446300000)],
+);
+
+// ./test/core/float_exprs.wast:473
+assert_return(
+  () => invoke($27, `f64.no_fuse_reciprocal_sqrt`, [
+    value("f64", 4472459252766337000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014952947335898096),
+  ],
+);
+
+// ./test/core/float_exprs.wast:474
+assert_return(
+  () => invoke($27, `f64.no_fuse_reciprocal_sqrt`, [
+    value("f64", 4752392260007119000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000014505872638954843),
+  ],
+);
+
+// ./test/core/float_exprs.wast:475
+assert_return(
+  () => invoke($27, `f64.no_fuse_reciprocal_sqrt`, [
+    value("f64", 29014415885392436000000000000000),
+  ]),
+  [value("f64", 0.00000000000000018564920084793608)],
+);
+
+// ./test/core/float_exprs.wast:476
+assert_return(
+  () => invoke($27, `f64.no_fuse_reciprocal_sqrt`, [
+    value("f64", 1396612507697477800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026758516751072132),
+  ],
+);
+
+// ./test/core/float_exprs.wast:477
+assert_return(
+  () => invoke($27, `f64.no_fuse_reciprocal_sqrt`, [
+    value("f64", 151596415440704430000000000000000000000000000),
+  ]),
+  [value("f64", 0.00000000000000000000008121860649480894)],
+);
+
+// ./test/core/float_exprs.wast:481
+let $28 = instantiate(`(module
+  (func (export "f32.no_approximate_sqrt_reciprocal") (param $$x f32) (result f32)
+    (f32.sqrt (f32.div (f32.const 1.0) (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:486
+assert_return(
+  () => invoke($28, `f32.no_approximate_sqrt_reciprocal`, [
+    value("f32", 1895057100000000000),
+  ]),
+  [value("f32", 0.00000000072642176)],
+);
+
+// ./test/core/float_exprs.wast:487
+assert_return(
+  () => invoke($28, `f32.no_approximate_sqrt_reciprocal`, [value("f32", 0.002565894)]),
+  [value("f32", 19.741522)],
+);
+
+// ./test/core/float_exprs.wast:488
+assert_return(
+  () => invoke($28, `f32.no_approximate_sqrt_reciprocal`, [
+    value("f32", 632654500000000000000),
+  ]),
+  [value("f32", 0.000000000039757284)],
+);
+
+// ./test/core/float_exprs.wast:489
+assert_return(
+  () => invoke($28, `f32.no_approximate_sqrt_reciprocal`, [value("f32", 14153.539)]),
+  [value("f32", 0.008405576)],
+);
+
+// ./test/core/float_exprs.wast:490
+assert_return(
+  () => invoke($28, `f32.no_approximate_sqrt_reciprocal`, [
+    value("f32", 26173730000000000000000000000000),
+  ]),
+  [value("f32", 0.00000000000000019546418)],
+);
+
+// ./test/core/float_exprs.wast:494
+let $29 = instantiate(`(module
+  (func (export "i32.no_fold_f32_s") (param i32) (result i32)
+    (i32.trunc_f32_s (f32.convert_i32_s (local.get 0))))
+  (func (export "i32.no_fold_f32_u") (param i32) (result i32)
+    (i32.trunc_f32_u (f32.convert_i32_u (local.get 0))))
+  (func (export "i64.no_fold_f64_s") (param i64) (result i64)
+    (i64.trunc_f64_s (f64.convert_i64_s (local.get 0))))
+  (func (export "i64.no_fold_f64_u") (param i64) (result i64)
+    (i64.trunc_f64_u (f64.convert_i64_u (local.get 0))))
+)`);
+
+// ./test/core/float_exprs.wast:505
+assert_return(() => invoke($29, `i32.no_fold_f32_s`, [16777216]), [value("i32", 16777216)]);
+
+// ./test/core/float_exprs.wast:506
+assert_return(() => invoke($29, `i32.no_fold_f32_s`, [16777217]), [value("i32", 16777216)]);
+
+// ./test/core/float_exprs.wast:507
+assert_return(() => invoke($29, `i32.no_fold_f32_s`, [-268435440]), [value("i32", -268435440)]);
+
+// ./test/core/float_exprs.wast:509
+assert_return(() => invoke($29, `i32.no_fold_f32_u`, [16777216]), [value("i32", 16777216)]);
+
+// ./test/core/float_exprs.wast:510
+assert_return(() => invoke($29, `i32.no_fold_f32_u`, [16777217]), [value("i32", 16777216)]);
+
+// ./test/core/float_exprs.wast:511
+assert_return(() => invoke($29, `i32.no_fold_f32_u`, [-268435440]), [value("i32", -268435456)]);
+
+// ./test/core/float_exprs.wast:513
+assert_return(
+  () => invoke($29, `i64.no_fold_f64_s`, [9007199254740992n]),
+  [value("i64", 9007199254740992n)],
+);
+
+// ./test/core/float_exprs.wast:514
+assert_return(
+  () => invoke($29, `i64.no_fold_f64_s`, [9007199254740993n]),
+  [value("i64", 9007199254740992n)],
+);
+
+// ./test/core/float_exprs.wast:515
+assert_return(
+  () => invoke($29, `i64.no_fold_f64_s`, [-1152921504606845952n]),
+  [value("i64", -1152921504606845952n)],
+);
+
+// ./test/core/float_exprs.wast:517
+assert_return(
+  () => invoke($29, `i64.no_fold_f64_u`, [9007199254740992n]),
+  [value("i64", 9007199254740992n)],
+);
+
+// ./test/core/float_exprs.wast:518
+assert_return(
+  () => invoke($29, `i64.no_fold_f64_u`, [9007199254740993n]),
+  [value("i64", 9007199254740992n)],
+);
+
+// ./test/core/float_exprs.wast:519
+assert_return(
+  () => invoke($29, `i64.no_fold_f64_u`, [-1152921504606845952n]),
+  [value("i64", -1152921504606846976n)],
+);
+
+// ./test/core/float_exprs.wast:523
+let $30 = instantiate(`(module
+  (func (export "f32.no_fold_add_sub") (param $$x f32) (param $$y f32) (result f32)
+    (f32.sub (f32.add (local.get $$x) (local.get $$y)) (local.get $$y)))
+  (func (export "f64.no_fold_add_sub") (param $$x f64) (param $$y f64) (result f64)
+    (f64.sub (f64.add (local.get $$x) (local.get $$y)) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:530
+assert_return(
+  () => invoke($30, `f32.no_fold_add_sub`, [
+    value("f32", 0.000000000000012138282),
+    value("f32", -0.000000020946384),
+  ]),
+  [value("f32", 0.000000000000012434498)],
+);
+
+// ./test/core/float_exprs.wast:531
+assert_return(
+  () => invoke($30, `f32.no_fold_add_sub`, [
+    value("f32", -0.00000019768197),
+    value("f32", 0.0000037154566),
+  ]),
+  [value("f32", -0.00000019768208)],
+);
+
+// ./test/core/float_exprs.wast:532
+assert_return(
+  () => invoke($30, `f32.no_fold_add_sub`, [
+    value("f32", -9596213000000000000000000),
+    value("f32", -3538041400000000000000000000000),
+  ]),
+  [value("f32", -9671407000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:533
+assert_return(
+  () => invoke($30, `f32.no_fold_add_sub`, [
+    value("f32", 0.000000000000000000000005054346),
+    value("f32", 0.000000000000000024572656),
+  ]),
+  [value("f32", 0.0000000000000000000000049630837)],
+);
+
+// ./test/core/float_exprs.wast:534
+assert_return(
+  () => invoke($30, `f32.no_fold_add_sub`, [
+    value("f32", -0.0000000000000000000000000000000033693147),
+    value("f32", -0.000000000000000000000000071014917),
+  ]),
+  [value("f32", -0.000000000000000000000000000000006162976)],
+);
+
+// ./test/core/float_exprs.wast:536
+assert_return(
+  () => invoke($30, `f64.no_fold_add_sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008445702651973109),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001110684389828854),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008445702651873978),
+  ],
+);
+
+// ./test/core/float_exprs.wast:537
+assert_return(
+  () => invoke($30, `f64.no_fold_add_sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008198798715927055),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004624035606110903),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008198798715897085),
+  ],
+);
+
+// ./test/core/float_exprs.wast:538
+assert_return(
+  () => invoke($30, `f64.no_fold_add_sub`, [
+    value("f64", -0.0000000013604511322066714),
+    value("f64", -0.1751431740707098),
+  ]),
+  [value("f64", -0.0000000013604511406306585)],
+);
+
+// ./test/core/float_exprs.wast:539
+assert_return(
+  () => invoke($30, `f64.no_fold_add_sub`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003944335437865966),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001663809741322667),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039443355500325104),
+  ],
+);
+
+// ./test/core/float_exprs.wast:540
+assert_return(
+  () => invoke($30, `f64.no_fold_add_sub`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078309818866),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010790431644461104),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000507831047937567),
+  ],
+);
+
+// ./test/core/float_exprs.wast:544
+let $31 = instantiate(`(module
+  (func (export "f32.no_fold_sub_add") (param $$x f32) (param $$y f32) (result f32)
+    (f32.add (f32.sub (local.get $$x) (local.get $$y)) (local.get $$y)))
+  (func (export "f64.no_fold_sub_add") (param $$x f64) (param $$y f64) (result f64)
+    (f64.add (f64.sub (local.get $$x) (local.get $$y)) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:551
+assert_return(
+  () => invoke($31, `f32.no_fold_sub_add`, [
+    value("f32", -676.47437),
+    value("f32", 403.0368),
+  ]),
+  [value("f32", -676.4744)],
+);
+
+// ./test/core/float_exprs.wast:552
+assert_return(
+  () => invoke($31, `f32.no_fold_sub_add`, [
+    value("f32", -0.0000000000000000000000000000000006305943),
+    value("f32", 0.0000000000000000000000000000367186),
+  ]),
+  [value("f32", -0.00000000000000000000000000000000063194576)],
+);
+
+// ./test/core/float_exprs.wast:553
+assert_return(
+  () => invoke($31, `f32.no_fold_sub_add`, [
+    value("f32", 83184800),
+    value("f32", 46216217000),
+  ]),
+  [value("f32", 83185660)],
+);
+
+// ./test/core/float_exprs.wast:554
+assert_return(
+  () => invoke($31, `f32.no_fold_sub_add`, [
+    value("f32", 0.000000000002211957),
+    value("f32", -0.00000001043793),
+  ]),
+  [value("f32", 0.0000000000022115643)],
+);
+
+// ./test/core/float_exprs.wast:555
+assert_return(
+  () => invoke($31, `f32.no_fold_sub_add`, [
+    value("f32", 0.14944395),
+    value("f32", -27393.65),
+  ]),
+  [value("f32", 0.15039063)],
+);
+
+// ./test/core/float_exprs.wast:557
+assert_return(
+  () => invoke($31, `f64.no_fold_sub_add`, [
+    value("f64", 90365982617946240000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -958186427535552000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 90365982617946280000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:558
+assert_return(
+  () => invoke($31, `f64.no_fold_sub_add`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044230403564658815),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026713491049366576),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004423040356647721),
+  ],
+);
+
+// ./test/core/float_exprs.wast:559
+assert_return(
+  () => invoke($31, `f64.no_fold_sub_add`, [
+    value("f64", 4095348452776429000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -4050190019576568700000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 4070815637249397500000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:560
+assert_return(
+  () => invoke($31, `f64.no_fold_sub_add`, [
+    value("f64", 0.000000024008889207554433),
+    value("f64", -0.00017253797929188484),
+  ]),
+  [value("f64", 0.00000002400888920756506)],
+);
+
+// ./test/core/float_exprs.wast:561
+assert_return(
+  () => invoke($31, `f64.no_fold_sub_add`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043367542918305866),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000039597706708227122),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004336754291830597),
+  ],
+);
+
+// ./test/core/float_exprs.wast:565
+let $32 = instantiate(`(module
+  (func (export "f32.no_fold_mul_div") (param $$x f32) (param $$y f32) (result f32)
+    (f32.div (f32.mul (local.get $$x) (local.get $$y)) (local.get $$y)))
+  (func (export "f64.no_fold_mul_div") (param $$x f64) (param $$y f64) (result f64)
+    (f64.div (f64.mul (local.get $$x) (local.get $$y)) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:572
+assert_return(
+  () => invoke($32, `f32.no_fold_mul_div`, [
+    value("f32", -32476715000000000),
+    value("f32", 0.000000000000010121375),
+  ]),
+  [value("f32", -32476713000000000)],
+);
+
+// ./test/core/float_exprs.wast:573
+assert_return(
+  () => invoke($32, `f32.no_fold_mul_div`, [
+    value("f32", -0.000000015561163),
+    value("f32", 0.000000000000000000000000000000015799828),
+  ]),
+  [value("f32", -0.000000015561145)],
+);
+
+// ./test/core/float_exprs.wast:574
+assert_return(
+  () => invoke($32, `f32.no_fold_mul_div`, [
+    value("f32", -0.00000000000000676311),
+    value("f32", -441324000000000),
+  ]),
+  [value("f32", -0.0000000000000067631096)],
+);
+
+// ./test/core/float_exprs.wast:575
+assert_return(
+  () => invoke($32, `f32.no_fold_mul_div`, [
+    value("f32", 7505613700000000),
+    value("f32", -2160384100000000000),
+  ]),
+  [value("f32", 7505613000000000)],
+);
+
+// ./test/core/float_exprs.wast:576
+assert_return(
+  () => invoke($32, `f32.no_fold_mul_div`, [
+    value("f32", -0.0000000000000000000000000002362576),
+    value("f32", -0.000000000010808759),
+  ]),
+  [value("f32", -0.00000000000000000000000000023625765)],
+);
+
+// ./test/core/float_exprs.wast:578
+assert_return(
+  () => invoke($32, `f64.no_fold_mul_div`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013532103713575586),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000003347836467564916),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013532103713672434),
+  ],
+);
+
+// ./test/core/float_exprs.wast:579
+assert_return(
+  () => invoke($32, `f64.no_fold_mul_div`, [
+    value("f64", 77662174313180845000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 195959155606939530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 77662174313180850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:580
+assert_return(
+  () => invoke($32, `f64.no_fold_mul_div`, [
+    value("f64", -718011781190294800000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009320036042623636),
+  ]),
+  [
+    value("f64", -718011781190294750000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:581
+assert_return(
+  () => invoke($32, `f64.no_fold_mul_div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000017260010724693063),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003568792428129926),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000001661286799244216),
+  ],
+);
+
+// ./test/core/float_exprs.wast:582
+assert_return(
+  () => invoke($32, `f64.no_fold_mul_div`, [
+    value("f64", -9145223045828962000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562094034342845),
+  ]),
+  [
+    value("f64", -9145223045828963000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:586
+let $33 = instantiate(`(module
+  (func (export "f32.no_fold_div_mul") (param $$x f32) (param $$y f32) (result f32)
+    (f32.mul (f32.div (local.get $$x) (local.get $$y)) (local.get $$y)))
+  (func (export "f64.no_fold_div_mul") (param $$x f64) (param $$y f64) (result f64)
+    (f64.mul (f64.div (local.get $$x) (local.get $$y)) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:593
+assert_return(
+  () => invoke($33, `f32.no_fold_div_mul`, [
+    value("f32", -511517980000),
+    value("f32", 986062200),
+  ]),
+  [value("f32", -511517950000)],
+);
+
+// ./test/core/float_exprs.wast:594
+assert_return(
+  () => invoke($33, `f32.no_fold_div_mul`, [
+    value("f32", -0.00000000000000024944853),
+    value("f32", -0.0000041539834),
+  ]),
+  [value("f32", -0.00000000000000024944856)],
+);
+
+// ./test/core/float_exprs.wast:595
+assert_return(
+  () => invoke($33, `f32.no_fold_div_mul`, [
+    value("f32", 0.000000000000000000000000000000000000020827855),
+    value("f32", -235.19847),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000020828013)],
+);
+
+// ./test/core/float_exprs.wast:596
+assert_return(
+  () => invoke($33, `f32.no_fold_div_mul`, [
+    value("f32", -0.000000000000000000000062499487),
+    value("f32", -696312600000000000),
+  ]),
+  [value("f32", -0.00000000000000000000006249919)],
+);
+
+// ./test/core/float_exprs.wast:597
+assert_return(
+  () => invoke($33, `f32.no_fold_div_mul`, [
+    value("f32", 0.0000000000000000000000000000058353514),
+    value("f32", 212781120),
+  ]),
+  [value("f32", 0.000000000000000000000000000005835352)],
+);
+
+// ./test/core/float_exprs.wast:599
+assert_return(
+  () => invoke($33, `f64.no_fold_div_mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035984644259935362),
+    value("f64", -28812263298033320000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035985034356565485),
+  ],
+);
+
+// ./test/core/float_exprs.wast:600
+assert_return(
+  () => invoke($33, `f64.no_fold_div_mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017486367047479447),
+    value("f64", 0.00000000000000016508738454798636),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001748636704747945),
+  ],
+);
+
+// ./test/core/float_exprs.wast:601
+assert_return(
+  () => invoke($33, `f64.no_fold_div_mul`, [
+    value("f64", -0.00000000000000000000000000000000000000000003140341989542684),
+    value("f64", 942829809081919600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000031403419895426836),
+  ],
+);
+
+// ./test/core/float_exprs.wast:602
+assert_return(
+  () => invoke($33, `f64.no_fold_div_mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000003919745428533519),
+    value("f64", -21314747179654705000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000039197454285335185),
+  ],
+);
+
+// ./test/core/float_exprs.wast:603
+assert_return(
+  () => invoke($33, `f64.no_fold_div_mul`, [
+    value("f64", -5734160003788982000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 6350805843612229000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -5734160003788981000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:607
+let $34 = instantiate(`(module
+  (func (export "f32.no_fold_div2_mul2") (param $$x f32) (result f32)
+    (f32.mul (f32.div (local.get $$x) (f32.const 2.0)) (f32.const 2.0)))
+  (func (export "f64.no_fold_div2_mul2") (param $$x f64) (result f64)
+    (f64.mul (f64.div (local.get $$x) (f64.const 2.0)) (f64.const 2.0)))
+)`);
+
+// ./test/core/float_exprs.wast:614
+assert_return(
+  () => invoke($34, `f32.no_fold_div2_mul2`, [
+    value("f32", 0.000000000000000000000000000000000000023509886),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000023509887)],
+);
+
+// ./test/core/float_exprs.wast:615
+assert_return(
+  () => invoke($34, `f64.no_fold_div2_mul2`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144023),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+  ],
+);
+
+// ./test/core/float_exprs.wast:619
+let $35 = instantiate(`(module
+  (func (export "no_fold_demote_promote") (param $$x f64) (result f64)
+    (f64.promote_f32 (f32.demote_f64 (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:624
+assert_return(
+  () => invoke($35, `no_fold_demote_promote`, [
+    value("f64", -0.00000000000000000000000000000000000000017176297220569481),
+  ]),
+  [value("f64", -0.00000000000000000000000000000000000000017176275796615013)],
+);
+
+// ./test/core/float_exprs.wast:625
+assert_return(
+  () => invoke($35, `no_fold_demote_promote`, [
+    value("f64", -0.000000000000000000000000028464775573304055),
+  ]),
+  [value("f64", -0.00000000000000000000000002846477619188087)],
+);
+
+// ./test/core/float_exprs.wast:626
+assert_return(
+  () => invoke($35, `no_fold_demote_promote`, [
+    value("f64", 208970699699909230000000000000000),
+  ]),
+  [value("f64", 208970700445326000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:627
+assert_return(
+  () => invoke($35, `no_fold_demote_promote`, [
+    value("f64", -0.0000000000000000000000000047074160416121775),
+  ]),
+  [value("f64", -0.0000000000000000000000000047074161331556024)],
+);
+
+// ./test/core/float_exprs.wast:628
+assert_return(
+  () => invoke($35, `no_fold_demote_promote`, [
+    value("f64", 23359451497950880000000000000000),
+  ]),
+  [value("f64", 23359452224542198000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:633
+let $36 = instantiate(`(module
+  (func (export "no_fold_promote_demote") (param $$x f32) (result f32)
+    (f32.demote_f64 (f64.promote_f32 (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:638
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [`arithmetic_nan`],
+);
+
+// ./test/core/float_exprs.wast:639
+assert_return(() => invoke($36, `no_fold_promote_demote`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:640
+assert_return(() => invoke($36, `no_fold_promote_demote`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:641
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_exprs.wast:642
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", -0.000000000000000000000000000000000000000000001),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_exprs.wast:643
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", 0.000000000000000000000000000000000000011754942),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/float_exprs.wast:644
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", -0.000000000000000000000000000000000000011754942),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/float_exprs.wast:645
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/float_exprs.wast:646
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", -0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/float_exprs.wast:647
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:648
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:649
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:650
+assert_return(
+  () => invoke($36, `no_fold_promote_demote`, [value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:654
+let $37 = instantiate(`(module
+  (func (export "no_demote_mixed_add") (param $$x f64) (param $$y f32) (result f32)
+    (f32.demote_f64 (f64.add (local.get $$x) (f64.promote_f32 (local.get $$y)))))
+  (func (export "no_demote_mixed_add_commuted") (param $$y f32) (param $$x f64) (result f32)
+    (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $$y)) (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:661
+assert_return(
+  () => invoke($37, `no_demote_mixed_add`, [
+    value("f64", 0.00000000000000000000000000004941266527909197),
+    value("f32", 0.0000000000000000000000000000000000018767183),
+  ]),
+  [value("f32", 0.000000000000000000000000000049412667)],
+);
+
+// ./test/core/float_exprs.wast:662
+assert_return(
+  () => invoke($37, `no_demote_mixed_add`, [
+    value("f64", 140851523637.69385),
+    value("f32", 401096440000),
+  ]),
+  [value("f32", 541947950000)],
+);
+
+// ./test/core/float_exprs.wast:663
+assert_return(
+  () => invoke($37, `no_demote_mixed_add`, [
+    value("f64", 0.0000000000000000000000000000000000020831160914192852),
+    value("f32", -0.0000000000000000000000000000000000006050095),
+  ]),
+  [value("f32", 0.0000000000000000000000000000000000014781066)],
+);
+
+// ./test/core/float_exprs.wast:664
+assert_return(
+  () => invoke($37, `no_demote_mixed_add`, [
+    value("f64", -0.0000010032827553674626),
+    value("f32", 0.0000000019312918),
+  ]),
+  [value("f32", -0.0000010013515)],
+);
+
+// ./test/core/float_exprs.wast:665
+assert_return(
+  () => invoke($37, `no_demote_mixed_add`, [
+    value("f64", -0.0000013840207035752711),
+    value("f32", -0.0000000000005202814),
+  ]),
+  [value("f32", -0.0000013840212)],
+);
+
+// ./test/core/float_exprs.wast:667
+assert_return(
+  () => invoke($37, `no_demote_mixed_add_commuted`, [
+    value("f32", 0.0000000000000000000000000000000000018767183),
+    value("f64", 0.00000000000000000000000000004941266527909197),
+  ]),
+  [value("f32", 0.000000000000000000000000000049412667)],
+);
+
+// ./test/core/float_exprs.wast:668
+assert_return(
+  () => invoke($37, `no_demote_mixed_add_commuted`, [
+    value("f32", 401096440000),
+    value("f64", 140851523637.69385),
+  ]),
+  [value("f32", 541947950000)],
+);
+
+// ./test/core/float_exprs.wast:669
+assert_return(
+  () => invoke($37, `no_demote_mixed_add_commuted`, [
+    value("f32", -0.0000000000000000000000000000000000006050095),
+    value("f64", 0.0000000000000000000000000000000000020831160914192852),
+  ]),
+  [value("f32", 0.0000000000000000000000000000000000014781066)],
+);
+
+// ./test/core/float_exprs.wast:670
+assert_return(
+  () => invoke($37, `no_demote_mixed_add_commuted`, [
+    value("f32", 0.0000000019312918),
+    value("f64", -0.0000010032827553674626),
+  ]),
+  [value("f32", -0.0000010013515)],
+);
+
+// ./test/core/float_exprs.wast:671
+assert_return(
+  () => invoke($37, `no_demote_mixed_add_commuted`, [
+    value("f32", -0.0000000000005202814),
+    value("f64", -0.0000013840207035752711),
+  ]),
+  [value("f32", -0.0000013840212)],
+);
+
+// ./test/core/float_exprs.wast:675
+let $38 = instantiate(`(module
+  (func (export "no_demote_mixed_sub") (param $$x f64) (param $$y f32) (result f32)
+    (f32.demote_f64 (f64.sub (local.get $$x) (f64.promote_f32 (local.get $$y)))))
+)`);
+
+// ./test/core/float_exprs.wast:680
+assert_return(
+  () => invoke($38, `no_demote_mixed_sub`, [
+    value("f64", 7869935327202668000000000),
+    value("f32", 4086347000000000000),
+  ]),
+  [value("f32", 7869931000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:681
+assert_return(
+  () => invoke($38, `no_demote_mixed_sub`, [
+    value("f64", -1535841968.9056544),
+    value("f32", 239897.28),
+  ]),
+  [value("f32", -1536081900)],
+);
+
+// ./test/core/float_exprs.wast:682
+assert_return(
+  () => invoke($38, `no_demote_mixed_sub`, [
+    value("f64", -102.19459272722602),
+    value("f32", 0.00039426138),
+  ]),
+  [value("f32", -102.194984)],
+);
+
+// ./test/core/float_exprs.wast:683
+assert_return(
+  () => invoke($38, `no_demote_mixed_sub`, [
+    value("f64", 0.00000000000000005645470375565188),
+    value("f32", 0.0000000000000000000005851077),
+  ]),
+  [value("f32", 0.00000000000000005645412)],
+);
+
+// ./test/core/float_exprs.wast:684
+assert_return(
+  () => invoke($38, `no_demote_mixed_sub`, [
+    value("f64", 27090.388466832894),
+    value("f32", 63120.89),
+  ]),
+  [value("f32", -36030.504)],
+);
+
+// ./test/core/float_exprs.wast:688
+let $39 = instantiate(`(module
+  (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $$x f32) (result f32)
+    (f32.convert_i32_s (i32.trunc_f32_s (local.get $$x))))
+  (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $$x f32) (result f32)
+    (f32.convert_i32_s (i32.trunc_f32_u (local.get $$x))))
+  (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $$x f32) (result f32)
+    (f32.convert_i32_u (i32.trunc_f32_s (local.get $$x))))
+  (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $$x f32) (result f32)
+    (f32.convert_i32_u (i32.trunc_f32_u (local.get $$x))))
+  (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $$x f64) (result f64)
+    (f64.convert_i32_s (i32.trunc_f64_s (local.get $$x))))
+  (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $$x f64) (result f64)
+    (f64.convert_i32_s (i32.trunc_f64_u (local.get $$x))))
+  (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $$x f64) (result f64)
+    (f64.convert_i32_u (i32.trunc_f64_s (local.get $$x))))
+  (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $$x f64) (result f64)
+    (f64.convert_i32_u (i32.trunc_f64_u (local.get $$x))))
+  (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $$x f32) (result f32)
+    (f32.convert_i64_s (i64.trunc_f32_s (local.get $$x))))
+  (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $$x f32) (result f32)
+    (f32.convert_i64_s (i64.trunc_f32_u (local.get $$x))))
+  (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $$x f32) (result f32)
+    (f32.convert_i64_u (i64.trunc_f32_s (local.get $$x))))
+  (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $$x f32) (result f32)
+    (f32.convert_i64_u (i64.trunc_f32_u (local.get $$x))))
+  (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $$x f64) (result f64)
+    (f64.convert_i64_s (i64.trunc_f64_s (local.get $$x))))
+  (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $$x f64) (result f64)
+    (f64.convert_i64_s (i64.trunc_f64_u (local.get $$x))))
+  (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $$x f64) (result f64)
+    (f64.convert_i64_u (i64.trunc_f64_s (local.get $$x))))
+  (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $$x f64) (result f64)
+    (f64.convert_i64_u (i64.trunc_f64_u (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:723
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_s_convert_s`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:724
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_s_convert_s`, [value("f32", -1.5)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/float_exprs.wast:725
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_u_convert_s`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:726
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_u_convert_s`, [value("f32", -0.5)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:727
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_s_convert_u`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:728
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_s_convert_u`, [value("f32", -1.5)]),
+  [value("f32", 4294967300)],
+);
+
+// ./test/core/float_exprs.wast:729
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_u_convert_u`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:730
+assert_return(
+  () => invoke($39, `f32.i32.no_fold_trunc_u_convert_u`, [value("f32", -0.5)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:732
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_s_convert_s`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:733
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_s_convert_s`, [value("f64", -1.5)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/float_exprs.wast:734
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_u_convert_s`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:735
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_u_convert_s`, [value("f64", -0.5)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:736
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_s_convert_u`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:737
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_s_convert_u`, [value("f64", -1.5)]),
+  [value("f64", 4294967295)],
+);
+
+// ./test/core/float_exprs.wast:738
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_u_convert_u`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:739
+assert_return(
+  () => invoke($39, `f64.i32.no_fold_trunc_u_convert_u`, [value("f64", -0.5)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:741
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_s_convert_s`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:742
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_s_convert_s`, [value("f32", -1.5)]),
+  [value("f32", -1)],
+);
+
+// ./test/core/float_exprs.wast:743
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_u_convert_s`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:744
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_u_convert_s`, [value("f32", -0.5)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:745
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_s_convert_u`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:746
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_s_convert_u`, [value("f32", -1.5)]),
+  [value("f32", 18446744000000000000)],
+);
+
+// ./test/core/float_exprs.wast:747
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_u_convert_u`, [value("f32", 1.5)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_exprs.wast:748
+assert_return(
+  () => invoke($39, `f32.i64.no_fold_trunc_u_convert_u`, [value("f32", -0.5)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:750
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_s_convert_s`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:751
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_s_convert_s`, [value("f64", -1.5)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/float_exprs.wast:752
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_u_convert_s`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:753
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_u_convert_s`, [value("f64", -0.5)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:754
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_s_convert_u`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:755
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_s_convert_u`, [value("f64", -1.5)]),
+  [value("f64", 18446744073709552000)],
+);
+
+// ./test/core/float_exprs.wast:756
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_u_convert_u`, [value("f64", 1.5)]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_exprs.wast:757
+assert_return(
+  () => invoke($39, `f64.i64.no_fold_trunc_u_convert_u`, [value("f64", -0.5)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:763
+let $40 = instantiate(`(module
+  (memory 1 1)
+  (func (export "init") (param $$i i32) (param $$x f32) (f32.store (local.get $$i) (local.get $$x)))
+
+  (func (export "run") (param $$n i32) (param $$z f32)
+    (local $$i i32)
+    (block $$exit
+      (loop $$cont
+        (f32.store
+          (local.get $$i)
+          (f32.div (f32.load (local.get $$i)) (local.get $$z))
+        )
+        (local.set $$i (i32.add (local.get $$i) (i32.const 4)))
+        (br_if $$cont (i32.lt_u (local.get $$i) (local.get $$n)))
+      )
+    )
+  )
+
+  (func (export "check") (param $$i i32) (result f32) (f32.load (local.get $$i)))
+)`);
+
+// ./test/core/float_exprs.wast:784
+invoke($40, `init`, [0, value("f32", 15.1)]);
+
+// ./test/core/float_exprs.wast:785
+invoke($40, `init`, [4, value("f32", 15.2)]);
+
+// ./test/core/float_exprs.wast:786
+invoke($40, `init`, [8, value("f32", 15.3)]);
+
+// ./test/core/float_exprs.wast:787
+invoke($40, `init`, [12, value("f32", 15.4)]);
+
+// ./test/core/float_exprs.wast:788
+assert_return(() => invoke($40, `check`, [0]), [value("f32", 15.1)]);
+
+// ./test/core/float_exprs.wast:789
+assert_return(() => invoke($40, `check`, [4]), [value("f32", 15.2)]);
+
+// ./test/core/float_exprs.wast:790
+assert_return(() => invoke($40, `check`, [8]), [value("f32", 15.3)]);
+
+// ./test/core/float_exprs.wast:791
+assert_return(() => invoke($40, `check`, [12]), [value("f32", 15.4)]);
+
+// ./test/core/float_exprs.wast:792
+invoke($40, `run`, [16, value("f32", 3)]);
+
+// ./test/core/float_exprs.wast:793
+assert_return(() => invoke($40, `check`, [0]), [value("f32", 5.0333333)]);
+
+// ./test/core/float_exprs.wast:794
+assert_return(() => invoke($40, `check`, [4]), [value("f32", 5.0666666)]);
+
+// ./test/core/float_exprs.wast:795
+assert_return(() => invoke($40, `check`, [8]), [value("f32", 5.1)]);
+
+// ./test/core/float_exprs.wast:796
+assert_return(() => invoke($40, `check`, [12]), [value("f32", 5.133333)]);
+
+// ./test/core/float_exprs.wast:798
+let $41 = instantiate(`(module
+  (memory 1 1)
+  (func (export "init") (param $$i i32) (param $$x f64) (f64.store (local.get $$i) (local.get $$x)))
+
+  (func (export "run") (param $$n i32) (param $$z f64)
+    (local $$i i32)
+    (block $$exit
+      (loop $$cont
+        (f64.store
+          (local.get $$i)
+          (f64.div (f64.load (local.get $$i)) (local.get $$z))
+        )
+        (local.set $$i (i32.add (local.get $$i) (i32.const 8)))
+        (br_if $$cont (i32.lt_u (local.get $$i) (local.get $$n)))
+      )
+    )
+  )
+
+  (func (export "check") (param $$i i32) (result f64) (f64.load (local.get $$i)))
+)`);
+
+// ./test/core/float_exprs.wast:819
+invoke($41, `init`, [0, value("f64", 15.1)]);
+
+// ./test/core/float_exprs.wast:820
+invoke($41, `init`, [8, value("f64", 15.2)]);
+
+// ./test/core/float_exprs.wast:821
+invoke($41, `init`, [16, value("f64", 15.3)]);
+
+// ./test/core/float_exprs.wast:822
+invoke($41, `init`, [24, value("f64", 15.4)]);
+
+// ./test/core/float_exprs.wast:823
+assert_return(() => invoke($41, `check`, [0]), [value("f64", 15.1)]);
+
+// ./test/core/float_exprs.wast:824
+assert_return(() => invoke($41, `check`, [8]), [value("f64", 15.2)]);
+
+// ./test/core/float_exprs.wast:825
+assert_return(() => invoke($41, `check`, [16]), [value("f64", 15.3)]);
+
+// ./test/core/float_exprs.wast:826
+assert_return(() => invoke($41, `check`, [24]), [value("f64", 15.4)]);
+
+// ./test/core/float_exprs.wast:827
+invoke($41, `run`, [32, value("f64", 3)]);
+
+// ./test/core/float_exprs.wast:828
+assert_return(() => invoke($41, `check`, [0]), [value("f64", 5.033333333333333)]);
+
+// ./test/core/float_exprs.wast:829
+assert_return(() => invoke($41, `check`, [8]), [value("f64", 5.066666666666666)]);
+
+// ./test/core/float_exprs.wast:830
+assert_return(() => invoke($41, `check`, [16]), [value("f64", 5.1000000000000005)]);
+
+// ./test/core/float_exprs.wast:831
+assert_return(() => invoke($41, `check`, [24]), [value("f64", 5.133333333333334)]);
+
+// ./test/core/float_exprs.wast:835
+let $42 = instantiate(`(module
+  (func (export "f32.ult") (param $$x f32) (param $$y f32) (result i32) (i32.eqz (f32.ge (local.get $$x) (local.get $$y))))
+  (func (export "f32.ule") (param $$x f32) (param $$y f32) (result i32) (i32.eqz (f32.gt (local.get $$x) (local.get $$y))))
+  (func (export "f32.ugt") (param $$x f32) (param $$y f32) (result i32) (i32.eqz (f32.le (local.get $$x) (local.get $$y))))
+  (func (export "f32.uge") (param $$x f32) (param $$y f32) (result i32) (i32.eqz (f32.lt (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.ult") (param $$x f64) (param $$y f64) (result i32) (i32.eqz (f64.ge (local.get $$x) (local.get $$y))))
+  (func (export "f64.ule") (param $$x f64) (param $$y f64) (result i32) (i32.eqz (f64.gt (local.get $$x) (local.get $$y))))
+  (func (export "f64.ugt") (param $$x f64) (param $$y f64) (result i32) (i32.eqz (f64.le (local.get $$x) (local.get $$y))))
+  (func (export "f64.uge") (param $$x f64) (param $$y f64) (result i32) (i32.eqz (f64.lt (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:847
+assert_return(() => invoke($42, `f32.ult`, [value("f32", 3), value("f32", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:848
+assert_return(() => invoke($42, `f32.ult`, [value("f32", 2), value("f32", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:849
+assert_return(() => invoke($42, `f32.ult`, [value("f32", 2), value("f32", 3)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:850
+assert_return(
+  () => invoke($42, `f32.ult`, [value("f32", 2), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:851
+assert_return(() => invoke($42, `f32.ule`, [value("f32", 3), value("f32", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:852
+assert_return(() => invoke($42, `f32.ule`, [value("f32", 2), value("f32", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:853
+assert_return(() => invoke($42, `f32.ule`, [value("f32", 2), value("f32", 3)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:854
+assert_return(
+  () => invoke($42, `f32.ule`, [value("f32", 2), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:855
+assert_return(() => invoke($42, `f32.ugt`, [value("f32", 3), value("f32", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:856
+assert_return(() => invoke($42, `f32.ugt`, [value("f32", 2), value("f32", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:857
+assert_return(() => invoke($42, `f32.ugt`, [value("f32", 2), value("f32", 3)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:858
+assert_return(
+  () => invoke($42, `f32.ugt`, [value("f32", 2), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:859
+assert_return(() => invoke($42, `f32.uge`, [value("f32", 3), value("f32", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:860
+assert_return(() => invoke($42, `f32.uge`, [value("f32", 2), value("f32", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:861
+assert_return(() => invoke($42, `f32.uge`, [value("f32", 2), value("f32", 3)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:862
+assert_return(
+  () => invoke($42, `f32.uge`, [value("f32", 2), bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:863
+assert_return(() => invoke($42, `f64.ult`, [value("f64", 3), value("f64", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:864
+assert_return(() => invoke($42, `f64.ult`, [value("f64", 2), value("f64", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:865
+assert_return(() => invoke($42, `f64.ult`, [value("f64", 2), value("f64", 3)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:866
+assert_return(
+  () => invoke($42, `f64.ult`, [
+    value("f64", 2),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:867
+assert_return(() => invoke($42, `f64.ule`, [value("f64", 3), value("f64", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:868
+assert_return(() => invoke($42, `f64.ule`, [value("f64", 2), value("f64", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:869
+assert_return(() => invoke($42, `f64.ule`, [value("f64", 2), value("f64", 3)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:870
+assert_return(
+  () => invoke($42, `f64.ule`, [
+    value("f64", 2),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:871
+assert_return(() => invoke($42, `f64.ugt`, [value("f64", 3), value("f64", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:872
+assert_return(() => invoke($42, `f64.ugt`, [value("f64", 2), value("f64", 2)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:873
+assert_return(() => invoke($42, `f64.ugt`, [value("f64", 2), value("f64", 3)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:874
+assert_return(
+  () => invoke($42, `f64.ugt`, [
+    value("f64", 2),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:875
+assert_return(() => invoke($42, `f64.uge`, [value("f64", 3), value("f64", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:876
+assert_return(() => invoke($42, `f64.uge`, [value("f64", 2), value("f64", 2)]), [value("i32", 1)]);
+
+// ./test/core/float_exprs.wast:877
+assert_return(() => invoke($42, `f64.uge`, [value("f64", 2), value("f64", 3)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:878
+assert_return(
+  () => invoke($42, `f64.uge`, [
+    value("f64", 2),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:882
+let $43 = instantiate(`(module
+  (func (export "f32.no_fold_lt_select") (param $$x f32) (param $$y f32) (result f32) (select (local.get $$x) (local.get $$y) (f32.lt (local.get $$x) (local.get $$y))))
+  (func (export "f32.no_fold_le_select") (param $$x f32) (param $$y f32) (result f32) (select (local.get $$x) (local.get $$y) (f32.le (local.get $$x) (local.get $$y))))
+  (func (export "f32.no_fold_gt_select") (param $$x f32) (param $$y f32) (result f32) (select (local.get $$x) (local.get $$y) (f32.gt (local.get $$x) (local.get $$y))))
+  (func (export "f32.no_fold_ge_select") (param $$x f32) (param $$y f32) (result f32) (select (local.get $$x) (local.get $$y) (f32.ge (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.no_fold_lt_select") (param $$x f64) (param $$y f64) (result f64) (select (local.get $$x) (local.get $$y) (f64.lt (local.get $$x) (local.get $$y))))
+  (func (export "f64.no_fold_le_select") (param $$x f64) (param $$y f64) (result f64) (select (local.get $$x) (local.get $$y) (f64.le (local.get $$x) (local.get $$y))))
+  (func (export "f64.no_fold_gt_select") (param $$x f64) (param $$y f64) (result f64) (select (local.get $$x) (local.get $$y) (f64.gt (local.get $$x) (local.get $$y))))
+  (func (export "f64.no_fold_ge_select") (param $$x f64) (param $$y f64) (result f64) (select (local.get $$x) (local.get $$y) (f64.ge (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:894
+assert_return(
+  () => invoke($43, `f32.no_fold_lt_select`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:895
+assert_return(
+  () => invoke($43, `f32.no_fold_lt_select`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:896
+assert_return(
+  () => invoke($43, `f32.no_fold_lt_select`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:897
+assert_return(
+  () => invoke($43, `f32.no_fold_lt_select`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:898
+assert_return(
+  () => invoke($43, `f32.no_fold_le_select`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:899
+assert_return(
+  () => invoke($43, `f32.no_fold_le_select`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:900
+assert_return(
+  () => invoke($43, `f32.no_fold_le_select`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:901
+assert_return(
+  () => invoke($43, `f32.no_fold_le_select`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:902
+assert_return(
+  () => invoke($43, `f32.no_fold_gt_select`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:903
+assert_return(
+  () => invoke($43, `f32.no_fold_gt_select`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:904
+assert_return(
+  () => invoke($43, `f32.no_fold_gt_select`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:905
+assert_return(
+  () => invoke($43, `f32.no_fold_gt_select`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:906
+assert_return(
+  () => invoke($43, `f32.no_fold_ge_select`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:907
+assert_return(
+  () => invoke($43, `f32.no_fold_ge_select`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:908
+assert_return(
+  () => invoke($43, `f32.no_fold_ge_select`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:909
+assert_return(
+  () => invoke($43, `f32.no_fold_ge_select`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:910
+assert_return(
+  () => invoke($43, `f64.no_fold_lt_select`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:911
+assert_return(
+  () => invoke($43, `f64.no_fold_lt_select`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:912
+assert_return(
+  () => invoke($43, `f64.no_fold_lt_select`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:913
+assert_return(
+  () => invoke($43, `f64.no_fold_lt_select`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:914
+assert_return(
+  () => invoke($43, `f64.no_fold_le_select`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:915
+assert_return(
+  () => invoke($43, `f64.no_fold_le_select`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:916
+assert_return(
+  () => invoke($43, `f64.no_fold_le_select`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:917
+assert_return(
+  () => invoke($43, `f64.no_fold_le_select`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:918
+assert_return(
+  () => invoke($43, `f64.no_fold_gt_select`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:919
+assert_return(
+  () => invoke($43, `f64.no_fold_gt_select`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:920
+assert_return(
+  () => invoke($43, `f64.no_fold_gt_select`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:921
+assert_return(
+  () => invoke($43, `f64.no_fold_gt_select`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:922
+assert_return(
+  () => invoke($43, `f64.no_fold_ge_select`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:923
+assert_return(
+  () => invoke($43, `f64.no_fold_ge_select`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:924
+assert_return(
+  () => invoke($43, `f64.no_fold_ge_select`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:925
+assert_return(
+  () => invoke($43, `f64.no_fold_ge_select`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:929
+let $44 = instantiate(`(module
+  (func (export "f32.no_fold_lt_if") (param $$x f32) (param $$y f32) (result f32)
+    (if (result f32) (f32.lt (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+  (func (export "f32.no_fold_le_if") (param $$x f32) (param $$y f32) (result f32)
+    (if (result f32) (f32.le (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+  (func (export "f32.no_fold_gt_if") (param $$x f32) (param $$y f32) (result f32)
+    (if (result f32) (f32.gt (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+  (func (export "f32.no_fold_ge_if") (param $$x f32) (param $$y f32) (result f32)
+    (if (result f32) (f32.ge (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+
+  (func (export "f64.no_fold_lt_if") (param $$x f64) (param $$y f64) (result f64)
+    (if (result f64) (f64.lt (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+  (func (export "f64.no_fold_le_if") (param $$x f64) (param $$y f64) (result f64)
+    (if (result f64) (f64.le (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+  (func (export "f64.no_fold_gt_if") (param $$x f64) (param $$y f64) (result f64)
+    (if (result f64) (f64.gt (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+  (func (export "f64.no_fold_ge_if") (param $$x f64) (param $$y f64) (result f64)
+    (if (result f64) (f64.ge (local.get $$x) (local.get $$y))
+      (then (local.get $$x)) (else (local.get $$y))
+    )
+  )
+)`);
+
+// ./test/core/float_exprs.wast:973
+assert_return(
+  () => invoke($44, `f32.no_fold_lt_if`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:974
+assert_return(
+  () => invoke($44, `f32.no_fold_lt_if`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:975
+assert_return(
+  () => invoke($44, `f32.no_fold_lt_if`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:976
+assert_return(
+  () => invoke($44, `f32.no_fold_lt_if`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:977
+assert_return(
+  () => invoke($44, `f32.no_fold_le_if`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:978
+assert_return(
+  () => invoke($44, `f32.no_fold_le_if`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:979
+assert_return(
+  () => invoke($44, `f32.no_fold_le_if`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:980
+assert_return(
+  () => invoke($44, `f32.no_fold_le_if`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:981
+assert_return(
+  () => invoke($44, `f32.no_fold_gt_if`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:982
+assert_return(
+  () => invoke($44, `f32.no_fold_gt_if`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:983
+assert_return(
+  () => invoke($44, `f32.no_fold_gt_if`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:984
+assert_return(
+  () => invoke($44, `f32.no_fold_gt_if`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:985
+assert_return(
+  () => invoke($44, `f32.no_fold_ge_if`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:986
+assert_return(
+  () => invoke($44, `f32.no_fold_ge_if`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:987
+assert_return(
+  () => invoke($44, `f32.no_fold_ge_if`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:988
+assert_return(
+  () => invoke($44, `f32.no_fold_ge_if`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:989
+assert_return(
+  () => invoke($44, `f64.no_fold_lt_if`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:990
+assert_return(
+  () => invoke($44, `f64.no_fold_lt_if`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:991
+assert_return(
+  () => invoke($44, `f64.no_fold_lt_if`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:992
+assert_return(
+  () => invoke($44, `f64.no_fold_lt_if`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:993
+assert_return(
+  () => invoke($44, `f64.no_fold_le_if`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:994
+assert_return(
+  () => invoke($44, `f64.no_fold_le_if`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:995
+assert_return(
+  () => invoke($44, `f64.no_fold_le_if`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:996
+assert_return(
+  () => invoke($44, `f64.no_fold_le_if`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:997
+assert_return(
+  () => invoke($44, `f64.no_fold_gt_if`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:998
+assert_return(
+  () => invoke($44, `f64.no_fold_gt_if`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:999
+assert_return(
+  () => invoke($44, `f64.no_fold_gt_if`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1000
+assert_return(
+  () => invoke($44, `f64.no_fold_gt_if`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1001
+assert_return(
+  () => invoke($44, `f64.no_fold_ge_if`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1002
+assert_return(
+  () => invoke($44, `f64.no_fold_ge_if`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1003
+assert_return(
+  () => invoke($44, `f64.no_fold_ge_if`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1004
+assert_return(
+  () => invoke($44, `f64.no_fold_ge_if`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1008
+let $45 = instantiate(`(module
+  (func (export "f32.no_fold_lt_select_to_abs") (param $$x f32) (result f32) (select (f32.neg (local.get $$x)) (local.get $$x) (f32.lt (local.get $$x) (f32.const 0.0))))
+  (func (export "f32.no_fold_le_select_to_abs") (param $$x f32) (result f32) (select (f32.neg (local.get $$x)) (local.get $$x) (f32.le (local.get $$x) (f32.const -0.0))))
+  (func (export "f32.no_fold_gt_select_to_abs") (param $$x f32) (result f32) (select (local.get $$x) (f32.neg (local.get $$x)) (f32.gt (local.get $$x) (f32.const -0.0))))
+  (func (export "f32.no_fold_ge_select_to_abs") (param $$x f32) (result f32) (select (local.get $$x) (f32.neg (local.get $$x)) (f32.ge (local.get $$x) (f32.const 0.0))))
+
+  (func (export "f64.no_fold_lt_select_to_abs") (param $$x f64) (result f64) (select (f64.neg (local.get $$x)) (local.get $$x) (f64.lt (local.get $$x) (f64.const 0.0))))
+  (func (export "f64.no_fold_le_select_to_abs") (param $$x f64) (result f64) (select (f64.neg (local.get $$x)) (local.get $$x) (f64.le (local.get $$x) (f64.const -0.0))))
+  (func (export "f64.no_fold_gt_select_to_abs") (param $$x f64) (result f64) (select (local.get $$x) (f64.neg (local.get $$x)) (f64.gt (local.get $$x) (f64.const -0.0))))
+  (func (export "f64.no_fold_ge_select_to_abs") (param $$x f64) (result f64) (select (local.get $$x) (f64.neg (local.get $$x)) (f64.ge (local.get $$x) (f64.const 0.0))))
+)`);
+
+// ./test/core/float_exprs.wast:1020
+assert_return(
+  () => invoke($45, `f32.no_fold_lt_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1021
+assert_return(
+  () => invoke($45, `f32.no_fold_lt_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1022
+assert_return(() => invoke($45, `f32.no_fold_lt_select_to_abs`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1023
+assert_return(() => invoke($45, `f32.no_fold_lt_select_to_abs`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1024
+assert_return(
+  () => invoke($45, `f32.no_fold_le_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1025
+assert_return(
+  () => invoke($45, `f32.no_fold_le_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1026
+assert_return(() => invoke($45, `f32.no_fold_le_select_to_abs`, [value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1027
+assert_return(() => invoke($45, `f32.no_fold_le_select_to_abs`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1028
+assert_return(
+  () => invoke($45, `f32.no_fold_gt_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1029
+assert_return(
+  () => invoke($45, `f32.no_fold_gt_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1030
+assert_return(() => invoke($45, `f32.no_fold_gt_select_to_abs`, [value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1031
+assert_return(() => invoke($45, `f32.no_fold_gt_select_to_abs`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1032
+assert_return(
+  () => invoke($45, `f32.no_fold_ge_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1033
+assert_return(
+  () => invoke($45, `f32.no_fold_ge_select_to_abs`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1034
+assert_return(() => invoke($45, `f32.no_fold_ge_select_to_abs`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1035
+assert_return(() => invoke($45, `f32.no_fold_ge_select_to_abs`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1036
+assert_return(
+  () => invoke($45, `f64.no_fold_lt_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1037
+assert_return(
+  () => invoke($45, `f64.no_fold_lt_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1038
+assert_return(() => invoke($45, `f64.no_fold_lt_select_to_abs`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1039
+assert_return(() => invoke($45, `f64.no_fold_lt_select_to_abs`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1040
+assert_return(
+  () => invoke($45, `f64.no_fold_le_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1041
+assert_return(
+  () => invoke($45, `f64.no_fold_le_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1042
+assert_return(() => invoke($45, `f64.no_fold_le_select_to_abs`, [value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1043
+assert_return(() => invoke($45, `f64.no_fold_le_select_to_abs`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1044
+assert_return(
+  () => invoke($45, `f64.no_fold_gt_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1045
+assert_return(
+  () => invoke($45, `f64.no_fold_gt_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1046
+assert_return(() => invoke($45, `f64.no_fold_gt_select_to_abs`, [value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1047
+assert_return(() => invoke($45, `f64.no_fold_gt_select_to_abs`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1048
+assert_return(
+  () => invoke($45, `f64.no_fold_ge_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1049
+assert_return(
+  () => invoke($45, `f64.no_fold_ge_select_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1050
+assert_return(() => invoke($45, `f64.no_fold_ge_select_to_abs`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1051
+assert_return(() => invoke($45, `f64.no_fold_ge_select_to_abs`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1055
+let $46 = instantiate(`(module
+  (func (export "f32.no_fold_lt_if_to_abs") (param $$x f32) (result f32)
+    (if (result f32) (f32.lt (local.get $$x) (f32.const 0.0))
+      (then (f32.neg (local.get $$x))) (else (local.get $$x))
+    )
+  )
+  (func (export "f32.no_fold_le_if_to_abs") (param $$x f32) (result f32)
+    (if (result f32) (f32.le (local.get $$x) (f32.const -0.0))
+      (then (f32.neg (local.get $$x))) (else (local.get $$x))
+    )
+  )
+  (func (export "f32.no_fold_gt_if_to_abs") (param $$x f32) (result f32)
+    (if (result f32) (f32.gt (local.get $$x) (f32.const -0.0))
+      (then (local.get $$x)) (else (f32.neg (local.get $$x)))
+    )
+  )
+  (func (export "f32.no_fold_ge_if_to_abs") (param $$x f32) (result f32)
+    (if (result f32) (f32.ge (local.get $$x) (f32.const 0.0))
+      (then (local.get $$x)) (else (f32.neg (local.get $$x)))
+    )
+  )
+
+  (func (export "f64.no_fold_lt_if_to_abs") (param $$x f64) (result f64)
+    (if (result f64) (f64.lt (local.get $$x) (f64.const 0.0))
+      (then (f64.neg (local.get $$x))) (else (local.get $$x))
+    )
+  )
+  (func (export "f64.no_fold_le_if_to_abs") (param $$x f64) (result f64)
+    (if (result f64) (f64.le (local.get $$x) (f64.const -0.0))
+      (then (f64.neg (local.get $$x))) (else (local.get $$x))
+    )
+  )
+  (func (export "f64.no_fold_gt_if_to_abs") (param $$x f64) (result f64)
+    (if (result f64) (f64.gt (local.get $$x) (f64.const -0.0))
+      (then (local.get $$x)) (else (f64.neg (local.get $$x)))
+    )
+  )
+  (func (export "f64.no_fold_ge_if_to_abs") (param $$x f64) (result f64)
+    (if (result f64) (f64.ge (local.get $$x) (f64.const 0.0))
+      (then (local.get $$x)) (else (f64.neg (local.get $$x)))
+    )
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1099
+assert_return(
+  () => invoke($46, `f32.no_fold_lt_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1100
+assert_return(
+  () => invoke($46, `f32.no_fold_lt_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1101
+assert_return(() => invoke($46, `f32.no_fold_lt_if_to_abs`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1102
+assert_return(() => invoke($46, `f32.no_fold_lt_if_to_abs`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1103
+assert_return(
+  () => invoke($46, `f32.no_fold_le_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1104
+assert_return(
+  () => invoke($46, `f32.no_fold_le_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1105
+assert_return(() => invoke($46, `f32.no_fold_le_if_to_abs`, [value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1106
+assert_return(() => invoke($46, `f32.no_fold_le_if_to_abs`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1107
+assert_return(
+  () => invoke($46, `f32.no_fold_gt_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1108
+assert_return(
+  () => invoke($46, `f32.no_fold_gt_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1109
+assert_return(() => invoke($46, `f32.no_fold_gt_if_to_abs`, [value("f32", 0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1110
+assert_return(() => invoke($46, `f32.no_fold_gt_if_to_abs`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1111
+assert_return(
+  () => invoke($46, `f32.no_fold_ge_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]),
+  [bytes("f32", [0x0, 0x0, 0xa0, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1112
+assert_return(
+  () => invoke($46, `f32.no_fold_ge_if_to_abs`, [bytes("f32", [0x0, 0x0, 0xc0, 0xff])]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1113
+assert_return(() => invoke($46, `f32.no_fold_ge_if_to_abs`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1114
+assert_return(() => invoke($46, `f32.no_fold_ge_if_to_abs`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1115
+assert_return(
+  () => invoke($46, `f64.no_fold_lt_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1116
+assert_return(
+  () => invoke($46, `f64.no_fold_lt_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1117
+assert_return(() => invoke($46, `f64.no_fold_lt_if_to_abs`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1118
+assert_return(() => invoke($46, `f64.no_fold_lt_if_to_abs`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1119
+assert_return(
+  () => invoke($46, `f64.no_fold_le_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1120
+assert_return(
+  () => invoke($46, `f64.no_fold_le_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1121
+assert_return(() => invoke($46, `f64.no_fold_le_if_to_abs`, [value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1122
+assert_return(() => invoke($46, `f64.no_fold_le_if_to_abs`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1123
+assert_return(
+  () => invoke($46, `f64.no_fold_gt_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1124
+assert_return(
+  () => invoke($46, `f64.no_fold_gt_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1125
+assert_return(() => invoke($46, `f64.no_fold_gt_if_to_abs`, [value("f64", 0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1126
+assert_return(() => invoke($46, `f64.no_fold_gt_if_to_abs`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1127
+assert_return(
+  () => invoke($46, `f64.no_fold_ge_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff])],
+);
+
+// ./test/core/float_exprs.wast:1128
+assert_return(
+  () => invoke($46, `f64.no_fold_ge_if_to_abs`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/float_exprs.wast:1129
+assert_return(() => invoke($46, `f64.no_fold_ge_if_to_abs`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1130
+assert_return(() => invoke($46, `f64.no_fold_ge_if_to_abs`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1135
+let $47 = instantiate(`(module
+  (func (export "f32.incorrect_correction") (result f32)
+    (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225))
+  )
+  (func (export "f64.incorrect_correction") (result f64)
+    (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1144
+assert_return(() => invoke($47, `f32.incorrect_correction`, []), [value("f32", 0.00000011920929)]);
+
+// ./test/core/float_exprs.wast:1145
+assert_return(
+  () => invoke($47, `f64.incorrect_correction`, []),
+  [value("f64", -0.0000000000000002220446049250313)],
+);
+
+// ./test/core/float_exprs.wast:1150
+let $48 = instantiate(`(module
+  (func (export "calculate") (result f32)
+    (local $$x f32)
+    (local $$r f32)
+    (local $$q f32)
+    (local $$z0 f32)
+    (local $$z1 f32)
+    (local.set $$x (f32.const 156.25))
+    (local.set $$r (f32.const 208.333333334))
+    (local.set $$q (f32.const 1.77951304201))
+    (local.set $$z0 (f32.div (f32.mul (f32.neg (local.get $$r)) (local.get $$x)) (f32.sub (f32.mul (local.get $$x) (local.get $$q)) (local.get $$r))))
+    (local.set $$z1 (f32.div (f32.mul (f32.neg (local.get $$r)) (local.get $$x)) (f32.sub (f32.mul (local.get $$x) (local.get $$q)) (local.get $$r))))
+    (block (br_if 0 (f32.eq (local.get $$z0) (local.get $$z1))) (unreachable))
+    (local.get $$z1)
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1167
+assert_return(() => invoke($48, `calculate`, []), [value("f32", -466.92685)]);
+
+// ./test/core/float_exprs.wast:1169
+let $49 = instantiate(`(module
+  (func (export "calculate") (result f64)
+    (local $$x f64)
+    (local $$r f64)
+    (local $$q f64)
+    (local $$z0 f64)
+    (local $$z1 f64)
+    (local.set $$x (f64.const 156.25))
+    (local.set $$r (f64.const 208.333333334))
+    (local.set $$q (f64.const 1.77951304201))
+    (local.set $$z0 (f64.div (f64.mul (f64.neg (local.get $$r)) (local.get $$x)) (f64.sub (f64.mul (local.get $$x) (local.get $$q)) (local.get $$r))))
+    (local.set $$z1 (f64.div (f64.mul (f64.neg (local.get $$r)) (local.get $$x)) (f64.sub (f64.mul (local.get $$x) (local.get $$q)) (local.get $$r))))
+    (block (br_if 0 (f64.eq (local.get $$z0) (local.get $$z1))) (unreachable))
+    (local.get $$z1)
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1186
+assert_return(() => invoke($49, `calculate`, []), [value("f64", -466.926956301738)]);
+
+// ./test/core/float_exprs.wast:1191
+let $50 = instantiate(`(module
+  (func (export "llvm_pr26746") (param $$x f32) (result f32)
+    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (local.get $$x)))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1197
+assert_return(() => invoke($50, `llvm_pr26746`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1202
+let $51 = instantiate(`(module
+  (func (export "llvm_pr27153") (param $$x i32) (result f32)
+    (f32.add (f32.convert_i32_s (i32.and (local.get $$x) (i32.const 268435455))) (f32.const -8388608.0))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1208
+assert_return(() => invoke($51, `llvm_pr27153`, [33554434]), [value("f32", 25165824)]);
+
+// ./test/core/float_exprs.wast:1213
+let $52 = instantiate(`(module
+  (func (export "llvm_pr27036") (param $$x i32) (param $$y i32) (result f32)
+    (f32.add (f32.convert_i32_s (i32.or (local.get $$x) (i32.const -25034805)))
+             (f32.convert_i32_s (i32.and (local.get $$y) (i32.const 14942208))))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1220
+assert_return(() => invoke($52, `llvm_pr27036`, [-25034805, 14942208]), [value("f32", -10092596)]);
+
+// ./test/core/float_exprs.wast:1230
+let $53 = instantiate(`(module
+  (func (export "thepast0") (param $$a f64) (param $$b f64) (param $$c f64) (param $$d f64) (result f64)
+    (f64.div (f64.mul (local.get $$a) (local.get $$b)) (f64.mul (local.get $$c) (local.get $$d)))
+  )
+
+  (func (export "thepast1") (param $$a f64) (param $$b f64) (param $$c f64) (result f64)
+    (f64.sub (f64.mul (local.get $$a) (local.get $$b)) (local.get $$c))
+  )
+
+  (func (export "thepast2") (param $$a f32) (param $$b f32) (param $$c f32) (result f32)
+    (f32.mul (f32.mul (local.get $$a) (local.get $$b)) (local.get $$c))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1244
+assert_return(
+  () => invoke($53, `thepast0`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    value("f64", 0.9999999999999999),
+    value("f64", 2),
+    value("f64", 0.5),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144023),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1245
+assert_return(
+  () => invoke($53, `thepast1`, [
+    value("f64", 0.00000000000000005551115123125783),
+    value("f64", 0.9999999999999999),
+    value("f64", 0.00000000000000005551115123125783),
+  ]),
+  [value("f64", -0.000000000000000000000000000000006162975822039155)],
+);
+
+// ./test/core/float_exprs.wast:1246
+assert_return(
+  () => invoke($53, `thepast2`, [
+    value("f32", 0.000000000000000000000000000000000000023509887),
+    value("f32", 0.5),
+    value("f32", 1),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/float_exprs.wast:1251
+let $54 = instantiate(`(module
+  (func (export "inverse") (param $$x f32) (result f32)
+    (f32.div (f32.const 1.0) (local.get $$x))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1257
+assert_return(() => invoke($54, `inverse`, [value("f32", 96)]), [value("f32", 0.010416667)]);
+
+// ./test/core/float_exprs.wast:1262
+let $55 = instantiate(`(module
+  (func (export "f32_sqrt_minus_2") (param $$x f32) (result f32)
+    (f32.sub (f32.sqrt (local.get $$x)) (f32.const 2.0))
+  )
+
+  (func (export "f64_sqrt_minus_2") (param $$x f64) (result f64)
+    (f64.sub (f64.sqrt (local.get $$x)) (f64.const 2.0))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1272
+assert_return(() => invoke($55, `f32_sqrt_minus_2`, [value("f32", 4)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1273
+assert_return(() => invoke($55, `f64_sqrt_minus_2`, [value("f64", 4)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1277
+let $56 = instantiate(`(module
+  (func (export "f32.no_fold_recip_recip") (param $$x f32) (result f32)
+    (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (local.get $$x))))
+
+  (func (export "f64.no_fold_recip_recip") (param $$x f64) (result f64)
+    (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:1285
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [value("f32", -70435790000000000000)]),
+  [value("f32", -70435784000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1286
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [
+    value("f32", 0.000000000000000000000012466101),
+  ]),
+  [value("f32", 0.0000000000000000000000124661)],
+);
+
+// ./test/core/float_exprs.wast:1287
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [
+    value("f32", 0.000000000000000000097184545),
+  ]),
+  [value("f32", 0.00000000000000000009718455)],
+);
+
+// ./test/core/float_exprs.wast:1288
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [value("f32", -30.400759)]),
+  [value("f32", -30.40076)],
+);
+
+// ./test/core/float_exprs.wast:1289
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [value("f32", 2331659200000000000000)]),
+  [value("f32", 2331659000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1291
+assert_return(() => invoke($56, `f32.no_fold_recip_recip`, [value("f32", -0)]), [value("f32", -0)]);
+
+// ./test/core/float_exprs.wast:1292
+assert_return(() => invoke($56, `f32.no_fold_recip_recip`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1293
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [value("f32", -Infinity)]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1294
+assert_return(
+  () => invoke($56, `f32.no_fold_recip_recip`, [value("f32", Infinity)]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1296
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [
+    value("f64", -657971534362886860000000000000000000000000000),
+  ]),
+  [value("f64", -657971534362886900000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1297
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [value("f64", -144246931868576430000)]),
+  [value("f64", -144246931868576420000)],
+);
+
+// ./test/core/float_exprs.wast:1298
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [
+    value("f64", 184994689206231350000000000000000000000000000000000),
+  ]),
+  [value("f64", 184994689206231330000000000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1299
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005779584288006583),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005779584288006582),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1300
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [
+    value("f64", 51501178696141640000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 51501178696141634000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1302
+assert_return(() => invoke($56, `f64.no_fold_recip_recip`, [value("f64", -0)]), [value("f64", -0)]);
+
+// ./test/core/float_exprs.wast:1303
+assert_return(() => invoke($56, `f64.no_fold_recip_recip`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1304
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [value("f64", -Infinity)]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1305
+assert_return(
+  () => invoke($56, `f64.no_fold_recip_recip`, [value("f64", Infinity)]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1309
+let $57 = instantiate(`(module
+  (func (export "f32.no_algebraic_factoring") (param $$x f32) (param $$y f32) (result f32)
+    (f32.mul (f32.add (local.get $$x) (local.get $$y))
+             (f32.sub (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.no_algebraic_factoring") (param $$x f64) (param $$y f64) (result f64)
+    (f64.mul (f64.add (local.get $$x) (local.get $$y))
+             (f64.sub (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1319
+assert_return(
+  () => invoke($57, `f32.no_algebraic_factoring`, [
+    value("f32", -0.000000000000000053711865),
+    value("f32", 0.00000000000000009744328),
+  ]),
+  [value("f32", -0.000000000000000000000000000000006610229)],
+);
+
+// ./test/core/float_exprs.wast:1320
+assert_return(
+  () => invoke($57, `f32.no_algebraic_factoring`, [
+    value("f32", -19756732),
+    value("f32", 32770204),
+  ]),
+  [value("f32", -683557800000000)],
+);
+
+// ./test/core/float_exprs.wast:1321
+assert_return(
+  () => invoke($57, `f32.no_algebraic_factoring`, [
+    value("f32", 52314150000000),
+    value("f32", -145309980000000),
+  ]),
+  [value("f32", -18378221000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1322
+assert_return(
+  () => invoke($57, `f32.no_algebraic_factoring`, [
+    value("f32", 195260.38),
+    value("f32", -227.75723),
+  ]),
+  [value("f32", 38126563000)],
+);
+
+// ./test/core/float_exprs.wast:1323
+assert_return(
+  () => invoke($57, `f32.no_algebraic_factoring`, [
+    value("f32", -237.48706),
+    value("f32", -972341.5),
+  ]),
+  [value("f32", -945447960000)],
+);
+
+// ./test/core/float_exprs.wast:1325
+assert_return(
+  () => invoke($57, `f64.no_algebraic_factoring`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009639720335949767),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008019175443606207),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006430717386609473),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1326
+assert_return(
+  () => invoke($57, `f64.no_algebraic_factoring`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005166066590392027),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001494333315888213),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026688244016362468),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1327
+assert_return(
+  () => invoke($57, `f64.no_algebraic_factoring`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002866135870517635),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012114355254268516),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014675678175314036),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1328
+assert_return(
+  () => invoke($57, `f64.no_algebraic_factoring`, [
+    value("f64", -1292099281007814900000000000000000000000000000000000000),
+    value("f64", 662717187728034000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -439192401389602300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1329
+assert_return(
+  () => invoke($57, `f64.no_algebraic_factoring`, [
+    value("f64", 26242795689010570000000000000000000),
+    value("f64", -1625023398605080200000000000),
+  ]),
+  [
+    value("f64", 688684325575149100000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1333
+let $58 = instantiate(`(module
+  (func (export "f32.no_algebraic_factoring") (param $$x f32) (param $$y f32) (result f32)
+    (f32.sub (f32.mul (local.get $$x) (local.get $$x))
+             (f32.mul (local.get $$y) (local.get $$y))))
+
+  (func (export "f64.no_algebraic_factoring") (param $$x f64) (param $$y f64) (result f64)
+    (f64.sub (f64.mul (local.get $$x) (local.get $$x))
+             (f64.mul (local.get $$y) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1343
+assert_return(
+  () => invoke($58, `f32.no_algebraic_factoring`, [
+    value("f32", 0.000000000000022102996),
+    value("f32", 0.0000000000031465275),
+  ]),
+  [value("f32", -0.0000000000000000000000099001476)],
+);
+
+// ./test/core/float_exprs.wast:1344
+assert_return(
+  () => invoke($58, `f32.no_algebraic_factoring`, [
+    value("f32", -3289460800000),
+    value("f32", -15941539000),
+  ]),
+  [value("f32", 10820299000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1345
+assert_return(
+  () => invoke($58, `f32.no_algebraic_factoring`, [
+    value("f32", 0.00036497542),
+    value("f32", -0.00016153714),
+  ]),
+  [value("f32", 0.000000107112804)],
+);
+
+// ./test/core/float_exprs.wast:1346
+assert_return(
+  () => invoke($58, `f32.no_algebraic_factoring`, [
+    value("f32", 0.000000000000065383266),
+    value("f32", -0.000000000000027412773),
+  ]),
+  [value("f32", 0.000000000000000000000000003523511)],
+);
+
+// ./test/core/float_exprs.wast:1347
+assert_return(
+  () => invoke($58, `f32.no_algebraic_factoring`, [
+    value("f32", 3609682000000000),
+    value("f32", -5260104400000000),
+  ]),
+  [value("f32", -14638896000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1349
+assert_return(
+  () => invoke($58, `f64.no_algebraic_factoring`, [
+    value("f64", 213640454349895100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -292858755839442800000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 45642243734743850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1350
+assert_return(
+  () => invoke($58, `f64.no_algebraic_factoring`, [
+    value("f64", -1229017115924435800000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -8222158919016600000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -67603897289562710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1351
+assert_return(
+  () => invoke($58, `f64.no_algebraic_factoring`, [
+    value("f64", 5477733829752.252),
+    value("f64", -970738900948.5906),
+  ]),
+  [value("f64", 29063233895797397000000000)],
+);
+
+// ./test/core/float_exprs.wast:1352
+assert_return(
+  () => invoke($58, `f64.no_algebraic_factoring`, [
+    value("f64", -10689141744923551000000000000000000000000000000000000000),
+    value("f64", -173378393593738040000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 114257751213007240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1353
+assert_return(
+  () => invoke($58, `f64.no_algebraic_factoring`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000010295699877022106),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000008952274637805908),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025858214767010105),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1358
+let $59 = instantiate(`(module
+  (memory (data
+    "\\01\\00\\00\\00\\01\\00\\00\\80\\01\\00\\00\\00\\01\\00\\00\\80"
+    "\\01\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00"
+    "\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00"
+  ))
+
+  (func (export "f32.simple_x4_sum")
+    (param $$i i32)
+    (param $$j i32)
+    (param $$k i32)
+    (local $$x0 f32) (local $$x1 f32) (local $$x2 f32) (local $$x3 f32)
+    (local $$y0 f32) (local $$y1 f32) (local $$y2 f32) (local $$y3 f32)
+    (local.set $$x0 (f32.load offset=0 (local.get $$i)))
+    (local.set $$x1 (f32.load offset=4 (local.get $$i)))
+    (local.set $$x2 (f32.load offset=8 (local.get $$i)))
+    (local.set $$x3 (f32.load offset=12 (local.get $$i)))
+    (local.set $$y0 (f32.load offset=0 (local.get $$j)))
+    (local.set $$y1 (f32.load offset=4 (local.get $$j)))
+    (local.set $$y2 (f32.load offset=8 (local.get $$j)))
+    (local.set $$y3 (f32.load offset=12 (local.get $$j)))
+    (f32.store offset=0 (local.get $$k) (f32.add (local.get $$x0) (local.get $$y0)))
+    (f32.store offset=4 (local.get $$k) (f32.add (local.get $$x1) (local.get $$y1)))
+    (f32.store offset=8 (local.get $$k) (f32.add (local.get $$x2) (local.get $$y2)))
+    (f32.store offset=12 (local.get $$k) (f32.add (local.get $$x3) (local.get $$y3)))
+  )
+
+  (func (export "f32.load")
+    (param $$k i32) (result f32)
+    (f32.load (local.get $$k))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1391
+assert_return(() => invoke($59, `f32.simple_x4_sum`, [0, 16, 32]), []);
+
+// ./test/core/float_exprs.wast:1392
+assert_return(
+  () => invoke($59, `f32.load`, [32]),
+  [value("f32", 0.000000000000000000000000000000000000000000003)],
+);
+
+// ./test/core/float_exprs.wast:1393
+assert_return(() => invoke($59, `f32.load`, [36]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1394
+assert_return(
+  () => invoke($59, `f32.load`, [40]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_exprs.wast:1395
+assert_return(
+  () => invoke($59, `f32.load`, [44]),
+  [value("f32", -0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_exprs.wast:1397
+let $60 = instantiate(`(module
+  (memory (data
+    "\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\80\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\80"
+    "\\01\\00\\00\\00\\00\\00\\00\\00\\01\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00"
+    "\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00\\00"
+  ))
+
+  (func (export "f64.simple_x4_sum")
+    (param $$i i32)
+    (param $$j i32)
+    (param $$k i32)
+    (local $$x0 f64) (local $$x1 f64) (local $$x2 f64) (local $$x3 f64)
+    (local $$y0 f64) (local $$y1 f64) (local $$y2 f64) (local $$y3 f64)
+    (local.set $$x0 (f64.load offset=0 (local.get $$i)))
+    (local.set $$x1 (f64.load offset=8 (local.get $$i)))
+    (local.set $$x2 (f64.load offset=16 (local.get $$i)))
+    (local.set $$x3 (f64.load offset=24 (local.get $$i)))
+    (local.set $$y0 (f64.load offset=0 (local.get $$j)))
+    (local.set $$y1 (f64.load offset=8 (local.get $$j)))
+    (local.set $$y2 (f64.load offset=16 (local.get $$j)))
+    (local.set $$y3 (f64.load offset=24 (local.get $$j)))
+    (f64.store offset=0 (local.get $$k) (f64.add (local.get $$x0) (local.get $$y0)))
+    (f64.store offset=8 (local.get $$k) (f64.add (local.get $$x1) (local.get $$y1)))
+    (f64.store offset=16 (local.get $$k) (f64.add (local.get $$x2) (local.get $$y2)))
+    (f64.store offset=24 (local.get $$k) (f64.add (local.get $$x3) (local.get $$y3)))
+  )
+
+  (func (export "f64.load")
+    (param $$k i32) (result f64)
+    (f64.load (local.get $$k))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1430
+assert_return(() => invoke($60, `f64.simple_x4_sum`, [0, 32, 64]), []);
+
+// ./test/core/float_exprs.wast:1431
+assert_return(
+  () => invoke($60, `f64.load`, [64]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1432
+assert_return(() => invoke($60, `f64.load`, [72]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1433
+assert_return(
+  () => invoke($60, `f64.load`, [80]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1434
+assert_return(
+  () => invoke($60, `f64.load`, [88]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1439
+let $61 = instantiate(`(module
+  (memory (data
+    "\\c4\\c5\\57\\24\\a5\\84\\c8\\0b\\6d\\b8\\4b\\2e\\f2\\76\\17\\1c\\ca\\4a\\56\\1e\\1b\\6e\\71\\22"
+    "\\5d\\17\\1e\\6e\\bf\\cd\\14\\5c\\c7\\21\\55\\51\\39\\9c\\1f\\b2\\51\\f0\\a3\\93\\d7\\c1\\2c\\ae"
+    "\\7e\\a8\\28\\3a\\01\\21\\f4\\0a\\58\\93\\f8\\42\\77\\9f\\83\\39\\6a\\5f\\ba\\f7\\0a\\d8\\51\\6a"
+    "\\34\\ca\\ad\\c6\\34\\0e\\d8\\26\\dc\\4c\\33\\1c\\ed\\29\\90\\a8\\78\\0f\\d1\\ce\\76\\31\\23\\83"
+    "\\b8\\35\\e8\\f2\\44\\b0\\d3\\a1\\fc\\bb\\32\\e1\\b0\\ba\\69\\44\\09\\d6\\d9\\7d\\ff\\2e\\c0\\5a"
+    "\\36\\14\\33\\14\\3e\\a9\\fa\\87\\6d\\8b\\bc\\ce\\9d\\a7\\fd\\c4\\e9\\85\\3f\\dd\\d7\\e1\\18\\a6"
+    "\\50\\26\\72\\6e\\3f\\73\\0f\\f8\\12\\93\\23\\34\\61\\76\\12\\48\\c0\\9b\\05\\93\\eb\\ac\\86\\de"
+    "\\94\\3e\\55\\e8\\8c\\e8\\dd\\e4\\fc\\95\\47\\be\\56\\03\\21\\20\\4c\\e6\\bf\\7b\\f6\\7f\\d5\\ba"
+    "\\73\\1c\\c1\\14\\8f\\c4\\27\\96\\b3\\bd\\33\\ff\\78\\41\\5f\\c0\\5a\\ce\\f6\\67\\6e\\73\\9a\\17"
+    "\\66\\70\\03\\f8\\ce\\27\\a3\\52\\b2\\9f\\3b\\bf\\fb\\ae\\ed\\d3\\5a\\f8\\37\\57\\f0\\f5\\6e\\ef"
+    "\\b1\\4d\\70\\3d\\54\\a7\\01\\9a\\85\\08\\48\\91\\f5\\9d\\0c\\60\\87\\5b\\d9\\54\\1e\\51\\6d\\88"
+    "\\8e\\08\\8c\\a5\\71\\3a\\56\\08\\67\\46\\8f\\8f\\13\\2a\\2c\\ec\\2c\\1f\\b4\\62\\2b\\6f\\41\\0a"
+    "\\c4\\65\\42\\a2\\31\\6b\\2c\\7d\\3e\\bb\\75\\ac\\86\\97\\30\\d9\\48\\cd\\9a\\1f\\56\\c4\\c6\\e4"
+    "\\12\\c0\\9d\\fb\\ee\\02\\8c\\ce\\1c\\f2\\1e\\a1\\78\\23\\db\\c4\\1e\\49\\03\\d3\\71\\cc\\08\\50"
+    "\\c5\\d8\\5c\\ed\\d5\\b5\\65\\ac\\b5\\c9\\21\\d2\\c9\\29\\76\\de\\f0\\30\\1a\\5b\\3c\\f2\\3b\\db"
+    "\\3a\\39\\82\\3a\\16\\08\\6f\\a8\\f1\\be\\69\\69\\99\\71\\a6\\05\\d3\\14\\93\\2a\\16\\f2\\2f\\11"
+    "\\c7\\7e\\20\\bb\\91\\44\\ee\\f8\\e4\\01\\53\\c0\\b9\\7f\\f0\\bf\\f0\\03\\9c\\6d\\b1\\df\\a2\\44"
+    "\\01\\6d\\6b\\71\\2b\\5c\\b3\\21\\19\\46\\5e\\8f\\db\\91\\d3\\7c\\78\\6b\\b7\\12\\00\\8f\\eb\\bd"
+    "\\8a\\f5\\d4\\2e\\c4\\c1\\1e\\df\\73\\63\\59\\47\\49\\03\\0a\\b7\\cf\\24\\cf\\9c\\0e\\44\\7a\\9e"
+    "\\14\\fb\\42\\bf\\9d\\39\\30\\9e\\a0\\ab\\2f\\d1\\ae\\9e\\6a\\83\\43\\e3\\55\\7d\\85\\bf\\63\\8a"
+    "\\f8\\96\\10\\1f\\fe\\6d\\e7\\22\\1b\\e1\\69\\46\\8a\\44\\c8\\c8\\f9\\0c\\2b\\19\\07\\a5\\02\\3e"
+    "\\f2\\30\\10\\9a\\85\\8a\\5f\\ef\\81\\45\\a0\\77\\b1\\03\\10\\73\\4b\\ae\\98\\9d\\47\\bf\\9a\\2d"
+    "\\3a\\d5\\0f\\03\\66\\e3\\3d\\53\\d9\\40\\ce\\1f\\6f\\32\\2f\\21\\2b\\23\\21\\6c\\62\\d4\\a7\\3e"
+    "\\a8\\ce\\28\\31\\2d\\00\\3d\\67\\5e\\af\\a0\\cf\\2e\\d2\\b9\\6b\\84\\eb\\69\\08\\3c\\62\\36\\be"
+    "\\12\\fd\\36\\7f\\88\\3e\\ad\\bc\\0b\\c0\\41\\c4\\50\\b6\\e3\\50\\31\\e8\\ce\\e2\\96\\65\\55\\9c"
+    "\\16\\46\\e6\\b0\\2d\\3a\\e8\\81\\05\\b0\\bf\\34\\f7\\bc\\10\\1c\\fb\\cc\\3c\\f1\\85\\97\\42\\9f"
+    "\\eb\\14\\8d\\3c\\bf\\d7\\17\\88\\49\\9d\\8b\\2b\\b2\\3a\\83\\d1\\4f\\04\\9e\\a1\\0f\\ad\\08\\9d"
+    "\\54\\af\\d1\\82\\c3\\ec\\32\\2f\\02\\8f\\05\\21\\2d\\a2\\b7\\e4\\f4\\6f\\2e\\81\\2b\\0b\\9c\\fc"
+    "\\cb\\fe\\74\\02\\f9\\db\\f4\\f3\\ea\\00\\a8\\ec\\d1\\99\\74\\26\\dd\\d6\\34\\d5\\25\\b1\\46\\dd"
+    "\\9c\\aa\\71\\f5\\60\\b0\\88\\c8\\e0\\0b\\59\\5a\\25\\4f\\29\\66\\f9\\e3\\2e\\fe\\e9\\da\\e5\\18"
+    "\\4f\\27\\62\\f4\\ce\\a4\\21\\95\\74\\c7\\57\\64\\27\\9a\\4c\\fd\\54\\7d\\61\\ce\\c3\\ac\\87\\46"
+    "\\9c\\fa\\ff\\09\\ca\\79\\97\\67\\24\\74\\ca\\d4\\21\\83\\26\\25\\19\\12\\37\\64\\19\\e5\\65\\e0"
+    "\\74\\75\\8e\\dd\\c8\\ef\\74\\c7\\d8\\21\\2b\\79\\04\\51\\46\\65\\60\\03\\5d\\fa\\d8\\f4\\65\\a4"
+    "\\9e\\5d\\23\\da\\d7\\8a\\92\\80\\a4\\de\\78\\3c\\f1\\57\\42\\6d\\cd\\c9\\2f\\d5\\a4\\9e\\ab\\40"
+    "\\f4\\cb\\1b\\d7\\a3\\ca\\fc\\eb\\a7\\01\\b2\\9a\\69\\4e\\46\\9b\\18\\4e\\dd\\79\\a7\\aa\\a6\\52"
+    "\\39\\1e\\ef\\30\\cc\\9b\\bd\\5b\\ee\\4c\\21\\6d\\30\\00\\72\\b0\\46\\5f\\08\\cf\\c5\\b9\\e0\\3e"
+    "\\c2\\b3\\0c\\dc\\8e\\64\\de\\19\\42\\79\\cf\\43\\ea\\43\\5d\\8e\\88\\f7\\ab\\15\\dc\\3f\\c8\\67"
+    "\\20\\db\\b8\\64\\b1\\47\\1f\\de\\f2\\cb\\3f\\59\\9f\\d8\\46\\90\\dc\\ae\\2f\\22\\f9\\e2\\31\\89"
+    "\\d9\\9c\\1c\\4c\\d3\\a9\\4a\\57\\84\\9c\\9f\\ea\\2c\\3c\\ae\\3c\\c3\\1e\\8b\\e5\\4e\\17\\01\\25"
+    "\\db\\34\\46\\5f\\15\\ea\\05\\0c\\7c\\d9\\45\\8c\\19\\d0\\73\\8a\\96\\16\\dd\\44\\f9\\05\\b7\\5b"
+    "\\71\\b0\\e6\\21\\36\\5f\\75\\89\\91\\73\\75\\ab\\7d\\ae\\d3\\73\\ec\\37\\c6\\ea\\55\\75\\ef\\ea"
+    "\\ab\\8b\\7b\\11\\dc\\6d\\1a\\b2\\6a\\c4\\25\\cf\\aa\\e3\\9f\\49\\49\\89\\cb\\37\\9b\\0a\\a7\\01"
+    "\\60\\70\\dc\\b7\\c8\\83\\e1\\42\\f5\\be\\ad\\62\\94\\ad\\8d\\a1"
+  ))
+
+  (func (export "f32.kahan_sum") (param $$p i32) (param $$n i32) (result f32)
+    (local $$sum f32)
+    (local $$c f32)
+    (local $$t f32)
+    (block $$exit
+      (loop $$top
+        (local.set $$t
+          (f32.sub
+            (f32.sub
+              (local.tee $$sum
+                (f32.add
+                  (local.get $$c)
+                  (local.tee $$t
+                    (f32.sub (f32.load (local.get $$p)) (local.get $$t))
+                  )
+                )
+              )
+              (local.get $$c)
+            )
+            (local.get $$t)
+          )
+        )
+        (local.set $$p (i32.add (local.get $$p) (i32.const 4)))
+        (local.set $$c (local.get $$sum))
+        (br_if $$top (local.tee $$n (i32.add (local.get $$n) (i32.const -1))))
+      )
+    )
+    (local.get $$sum)
+  )
+
+  (func (export "f32.plain_sum") (param $$p i32) (param $$n i32) (result f32)
+    (local $$sum f32)
+    (block $$exit
+      (loop $$top
+        (local.set $$sum (f32.add (local.get $$sum) (f32.load (local.get $$p))))
+        (local.set $$p (i32.add (local.get $$p) (i32.const 4)))
+        (local.set $$n (i32.add (local.get $$n) (i32.const -1)))
+        (br_if $$top (local.get $$n))
+      )
+    )
+    (local.get $$sum)
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1530
+assert_return(
+  () => invoke($61, `f32.kahan_sum`, [0, 256]),
+  [value("f32", -21558138000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1531
+assert_return(
+  () => invoke($61, `f32.plain_sum`, [0, 256]),
+  [value("f32", -16487540000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1533
+let $62 = instantiate(`(module
+  (memory (data "\\13\\05\\84\\42\\5d\\a2\\2c\\c6\\43\\db\\55\\a9\\cd\\da\\55\\e3\\73\\fc\\58\\d6\\ba\\d5\\00\\fd\\83\\35\\42\\88\\8b\\13\\5d\\38\\4a\\47\\0d\\72\\73\\a1\\1a\\ef\\c4\\45\\17\\57\\d8\\c9\\46\\e0\\8d\\6c\\e1\\37\\70\\c8\\83\\5b\\55\\5e\\5a\\2d\\73\\1e\\56\\c8\\e1\\6d\\69\\14\\78\\0a\\8a\\5a\\64\\3a\\09\\c7\\a8\\87\\c5\\f0\\d3\\5d\\e6\\03\\fc\\93\\be\\26\\ca\\d6\\a9\\91\\60\\bd\\b0\\ed\\ae\\f7\\30\\7e\\92\\3a\\6f\\a7\\59\\8e\\aa\\7d\\bf\\67\\58\\2a\\54\\f8\\4e\\fe\\ed\\35\\58\\a6\\51\\bf\\42\\e5\\4b\\66\\27\\24\\6d\\7f\\42\\2d\\28\\92\\18\\ec\\08\\ae\\e7\\55\\da\\b1\\a6\\65\\a5\\72\\50\\47\\1b\\b8\\a9\\54\\d7\\a6\\06\\5b\\0f\\42\\58\\83\\8a\\17\\82\\c6\\10\\43\\a0\\c0\\2e\\6d\\bc\\5a\\85\\53\\72\\7f\\ad\\44\\bc\\30\\3c\\55\\b2\\24\\9a\\74\\3a\\9e\\e1\\d8\\0f\\70\\fc\\a9\\3a\\cd\\93\\4b\\ec\\e3\\7e\\dd\\5d\\27\\cd\\f8\\a0\\9d\\1c\\11\\c0\\57\\2e\\fd\\c8\\13\\32\\cc\\3a\\1a\\7d\\a3\\41\\55\\ed\\c3\\82\\49\\2a\\04\\1e\\ef\\73\\b9\\2e\\2e\\e3\\5f\\f4\\df\\e6\\b2\\33\\0c\\39\\3f\\6f\\44\\6a\\03\\c1\\42\\b9\\fa\\b1\\c8\\ed\\a5\\58\\99\\7f\\ed\\b4\\72\\9e\\79\\eb\\fb\\43\\82\\45\\aa\\bb\\95\\d2\\ff\\28\\9e\\f6\\a1\\ad\\95\\d6\\55\\95\\0d\\6f\\60\\11\\c7\\78\\3e\\49\\f2\\7e\\48\\f4\\a2\\71\\d0\\13\\8e\\b3\\de\\99\\52\\e3\\45\\74\\ea\\76\\0e\\1b\\2a\\c8\\ee\\14\\01\\c4\\50\\5b\\36\\3c\\ef\\ba\\72\\a2\\a6\\08\\f8\\7b\\36\\9d\\f9\\ef\\0b\\c7\\56\\2d\\5c\\f0\\9d\\5d\\de\\fc\\b8\\ad\\0f\\64\\0e\\97\\15\\32\\26\\c2\\31\\e6\\05\\1e\\ef\\cb\\17\\1b\\6d\\15\\0b\\74\\5d\\d3\\2e\\f8\\6b\\86\\b4\\ba\\73\\52\\53\\99\\a9\\76\\20\\45\\c9\\40\\80\\6b\\14\\ed\\a1\\fa\\80\\46\\e6\\26\\d2\\e6\\98\\c4\\57\\bf\\c4\\1c\\a4\\90\\7a\\36\\94\\14\\ba\\15\\89\\6e\\e6\\9c\\37\\8c\\f4\\de\\12\\22\\5d\\a1\\79\\50\\67\\0d\\3d\\7a\\e9\\d4\\aa\\2e\\7f\\2a\\7a\\30\\3d\\ea\\5d\\12\\48\\fe\\e1\\18\\cd\\a4\\57\\a2\\87\\3e\\b6\\9a\\8b\\db\\da\\9d\\78\\9c\\cf\\8d\\b1\\4f\\90\\b4\\34\\e0\\9d\\f6\\ca\\fe\\4c\\3b\\78\\6d\\0a\\5c\\18\\9f\\61\\b9\\dd\\b4\\e0\\0f\\76\\e0\\1b\\69\\0d\\5e\\58\\73\\70\\5e\\0e\\2d\\a1\\7d\\ff\\20\\eb\\91\\34\\92\\ac\\38\\72\\2a\\1f\\8e\\71\\2e\\6a\\f1\\af\\c7\\27\\70\\d9\\c4\\57\\f7\\d2\\3c\\1d\\b8\\f0\\f0\\64\\cf\\dc\\ae\\be\\a3\\cc\\3e\\22\\7d\\4e\\69\\21\\63\\17\\ed\\03\\02\\54\\9a\\0f\\50\\4e\\13\\5a\\35\\a1\\22\\a4\\df\\86\\c2\\74\\79\\16\\b8\\69\\69\\a0\\52\\5d\\11\\64\\bd\\5b\\93\\fc\\69\\a0\\f4\\13\\d0\\81\\51\\dd\\fa\\0c\\15\\c3\\7a\\c9\\62\\7a\\a9\\1d\\c9\\e6\\5a\\b3\\5b\\97\\02\\3c\\64\\22\\12\\3c\\22\\90\\64\\2d\\30\\54\\4c\\b4\\a1\\22\\09\\57\\22\\5e\\8e\\38\\2b\\02\\a8\\ae\\f6\\be\\0d\\2b\\f2\\03\\ad\\fa\\10\\01\\71\\77\\2a\\30\\02\\95\\f6\\00\\3e\\d0\\c4\\8d\\34\\19\\50\\21\\0a\\bc\\50\\da\\3c\\30\\d6\\3a\\31\\94\\8d\\3a\\fe\\ef\\14\\57\\9d\\4b\\93\\00\\96\\24\\0c\\6f\\fd\\bc\\23\\76\\02\\6c\\eb\\52\\72\\80\\11\\7e\\80\\3a\\13\\12\\38\\1d\\38\\49\\95\\40\\27\\8a\\44\\7b\\e8\\dc\\6d\\8c\\8c\\8e\\3c\\b5\\b3\\18\\0e\\f6\\08\\1a\\84\\41\\35\\ff\\8b\\b8\\93\\40\\ea\\e1\\51\\1d\\89\\a5\\8d\\42\\68\\29\\ea\\2f\\c1\\7a\\52\\eb\\90\\5d\\4d\\d6\\80\\e3\\d7\\75\\48\\ce\\ed\\d3\\01\\1c\\8d\\5b\\a5\\94\\0d\\78\\cf\\f1\\06\\13\\2f\\98\\02\\a4\\6d\\2e\\6c\\f2\\d5\\74\\29\\89\\4c\\f9\\03\\f5\\c7\\18\\ad\\7a\\f0\\68\\f8\\5c\\d6\\59\\87\\6e\\d6\\3f\\06\\be\\86\\20\\e3\\41\\91\\22\\f3\\6e\\8b\\f0\\68\\1c\\57\\a7\\fc\\b0\\7c\\9e\\99\\0b\\96\\1a\\89\\5f\\e6\\0d\\7c\\08\\51\\a0\\a2\\67\\9a\\47\\00\\93\\6b\\f9\\28\\f0\\68\\db\\62\\f1\\e0\\65\\2c\\53\\33\\e0\\a7\\ca\\11\\42\\30\\f6\\af\\01\\c1\\65\\3d\\32\\01\\6f\\ab\\2e\\be\\d3\\8b\\be\\14\\c3\\ff\\ec\\fb\\f0\\f9\\c5\\0c\\05\\6f\\01\\09\\6b\\e3\\34\\31\\0c\\1f\\66\\a6\\42\\bc\\1a\\87\\49\\16\\16\\8c\\b0\\90\\0d\\34\\8c\\0a\\e1\\09\\5e\\10\\a4\\6b\\56\\cc\\f0\\c9\\bb\\dc\\b8\\5c\\ce\\f6\\cc\\8d\\75\\7e\\b3\\07\\88\\04\\2f\\b4\\5e\\c9\\e3\\4a\\23\\73\\19\\62\\6c\\9a\\03\\76\\44\\86\\9c\\60\\fc\\db\\72\\8f\\27\\a0\\dd\\b3\\c5\\da\\ff\\f9\\ec\\6a\\b1\\7b\\d3\\cf\\50\\37\\c9\\7a\\78\\0c\\e4\\3a\\b6\\f5\\e6\\f4\\98\\6e\\42\\7d\\35\\73\\8b\\45\\c0\\56\\97\\cd\\6d\\ce\\cf\\ad\\31\\b3\\c3\\54\\fa\\ef\\d5\\c0\\f4\\6a\\5f\\54\\e7\\49\\3e\\33\\0a\\30\\38\\fd\\d9\\05\\ff\\a5\\3f\\57\\46\\14\\b5\\91\\17\\ca\\6b\\98\\23\\7a\\65\\b3\\6c\\02\\b4\\cc\\79\\5d\\58\\d8\\b3\\d5\\94\\ae\\f4\\6d\\75\\65\\f7\\92\\bf\\7e\\47\\4c\\3c\\ee\\db\\ac\\f1\\32\\5d\\fb\\6f\\41\\1c\\34\\c8\\83\\4f\\c2\\58\\01\\be\\05\\3e\\66\\16\\a6\\04\\6d\\5d\\4f\\86\\09\\27\\82\\25\\12\\cd\\3a\\cd\\ce\\6b\\bc\\ca\\ac\\28\\9b\\ee\\6a\\25\\86\\9e\\45\\70\\c6\\d2\\bd\\3b\\7d\\42\\e5\\27\\af\\c7\\1d\\f4\\81\\c8\\b3\\76\\8a\\a8\\36\\a3\\ae\\2a\\e6\\18\\e1\\36\\22\\ad\\f6\\25\\72\\b0\\39\\8b\\01\\9a\\22\\7b\\84\\c3\\2d\\5f\\72\\a4\\98\\ac\\15\\70\\e7\\d4\\18\\e2\\7d\\d2\\30\\7c\\33\\08\\cd\\ca\\c4\\22\\85\\88\\75\\81\\c6\\4a\\74\\58\\8d\\e0\\e8\\ac\\c5\\ab\\75\\5a\\f4\\28\\12\\f0\\18\\45\\52\\f2\\97\\b2\\93\\41\\6f\\8d\\7f\\db\\70\\fb\\a3\\5d\\1f\\a7\\8d\\98\\20\\2b\\22\\9f\\3a\\01\\b5\\8b\\1b\\d2\\cb\\14\\03\\0e\\14\\14\\d2\\19\\5a\\1f\\ce\\5e\\cd\\81\\79\\15\\01\\ca\\de\\73\\74\\8c\\56\\20\\9f\\77\\2d\\25\\16\\f6\\61\\51\\1d\\a4\\8e\\9b\\98\\a5\\c6\\ec\\a8\\45\\57\\82\\59\\78\\0d\\90\\b4\\df\\51\\b0\\c3\\82\\94\\cc\\b3\\53\\09\\15\\6d\\96\\6c\\3a\\40\\47\\b7\\4a\\7a\\05\\2f\\a1\\1e\\8c\\9d\\a0\\20\\88\\fb\\52\\b7\\9f\\f3\\f3\\bb\\5f\\e7\\8a\\61\\a7\\21\\b1\\ac\\fa\\09\\aa\\a4\\6c\\bc\\24\\80\\ba\\2a\\e9\\65\\ff\\70\\ff\\cc\\fa\\65\\87\\76\\f3\\c5\\15\\ce\\cb\\e8\\42\\31\\00\\0c\\91\\57\\d9\\e0\\9d\\35\\54\\24\\ad\\a4\\d8\\f9\\08\\67\\63\\c8\\cf\\81\\dd\\90\\a2\\d7\\c4\\07\\4a\\e6\\10\\6f\\67\\e7\\27\\d4\\23\\59\\18\\f2\\a8\\9d\\5f\\d8\\94\\30\\aa\\54\\86\\4f\\87\\9d\\82\\b5\\26\\ca\\a6\\96\\bf\\cf\\55\\f9\\9d\\37\\01\\19\\48\\43\\c5\\94\\6c\\f3\\74\\97\\58\\4c\\3c\\9d\\08\\e8\\04\\c2\\58\\30\\76\\e1\\a0\\f8\\ea\\e9\\c5\\ae\\cf\\78\\9e\\a9\\0c\\ac\\b3\\44\\42\\e0\\bc\\5d\\1b\\9c\\49\\58\\4a\\1c\\19\\49\\c1\\3a\\ea\\f5\\eb\\3b\\81\\a9\\4b\\70\\0c\\cc\\9e\\1a\\d3\\2f\\b7\\52\\2f\\20\\3b\\eb\\64\\51\\1d\\a0\\2d\\b2\\3e\\be\\13\\85\\48\\92\\32\\2e\\db\\5c\\a1\\e7\\8c\\45\\91\\35\\01\\0a\\93\\c2\\eb\\09\\ce\\f3\\d2\\22\\24\\d0\\8c\\cc\\1d\\9d\\38\\c8\\4d\\e3\\82\\cc\\64\\15\\06\\2d\\e7\\01\\2f\\ab\\bb\\b5\\04\\4c\\92\\1c\\7a\\d6\\3f\\e8\\5f\\31\\15\\0c\\dc\\e4\\31\\b4\\c4\\25\\3e\\2a\\aa\\00\\9e\\c8\\e5\\21\\7a\\7f\\29\\f1\\c0\\af\\1d\\5e\\e8\\63\\39\\ad\\f8\\7e\\6c\\c8\\c5\\7f\\c2\\a8\\97\\27\\0a\\d9\\f4\\21\\6a\\ea\\03\\09\\fb\\f7\\96\\3b\\83\\79\\5f\\7c\\4b\\30\\9f\\56\\35\\de\\b4\\73\\d4\\95\\f0\\14\\c3\\74\\2f\\0d\\a3\\1d\\4e\\8d\\31\\24\\b3\\1a\\84\\85\\62\\5a\\7b\\3c\\14\\39\\17\\e6\\6d\\eb\\37\\c2\\00\\58\\5b\\0b\\e3\\3c\\8a\\62\\e1\\f8\\35\\4b\\56\\e2\\87\\60\\8b\\be\\a7\\38\\91\\77\\54\\a9\\5a\\24\\25\\90\\9f\\a5\\42\\77\\f3\\5c\\39\\df\\ff\\74\\07\\76\\a1\\cd\\1f\\62\\0b\\81\\81\\68\\af\\05\\c1\\c0\\7f\\26\\ee\\c0\\91\\a3\\6a\\7d\\29\\61\\45\\27\\e5\\57\\88\\dc\\0d\\97\\04\\1a\\33\\a9\\44\\8a\\da\\02\\10\\45\\3f\\8e\\55\\a6\\76\\8c\\4d\\e3\\f1\\89\\83\\c8\\d0\\f8\\9b\\50\\77\\9f\\47\\df\\4c\\9c\\66\\0d\\aa\\18\\b8\\5f\\4f\\c4\\01\\ce\\dc\\84\\ac\\46\\9e\\69\\e1\\76\\45\\6b\\61\\89\\e4\\5d\\94\\bb\\11\\83\\9f\\78\\d8\\0a\\d2\\f5\\7e\\5d\\43\\ea\\bc\\10\\f1\\3a\\c9\\e2\\64\\fb\\53\\65\\d0\\c7\\b4\\a7\\fb\\d4\\05\\53\\25\\d0\\cd\\29\\88\\00\\56\\25\\24\\7d\\5d\\b4\\f3\\41\\9f\\e9\\b5\\f7\\ae\\64\\2c\\e3\\c9\\6d\\d5\\84\\3a\\72\\12\\b8\\7a\\d9\\1b\\09\\e8\\38\\da\\26\\4f\\04\\ce\\03\\71\\6e\\8a\\44\\7b\\5c\\81\\59\\9c\\d2\\e4\\c3\\ba\\59\\a6\\e5\\28\\a7\\8f\\9a\\e4\\d5\\4e\\b9\\ca\\7f\\cb\\75\\b8\\2b\\43\\3e\\b3\\15\\46\\b1\\a5\\bc\\9d\\9e\\38\\15\\f1\\bd\\1b\\21\\aa\\f1\\82\\00\\95\\fc\\a7\\77\\47\\39\\a7\\33\\43\\92\\d7\\52\\40\\4b\\06\\81\\8a\\a0\\bd\\f1\\6b\\99\\84\\42\\5b\\e2\\3b\\c5\\5e\\12\\5c\\28\\4d\\b6\\0e\\4e\\c8\\5c\\e8\\01\\8a\\c5\\e7\\e4\\9d\\42\\ee\\5d\\9c\\c4\\eb\\eb\\68\\09\\27\\92\\95\\9a\\11\\54\\73\\c4\\12\\80\\fb\\7d\\fe\\c5\\08\\60\\7f\\36\\41\\e0\\10\\ba\\d6\\2b\\6c\\f1\\b4\\17\\fe\\26\\34\\e3\\4b\\f8\\a8\\e3\\91\\be\\4f\\2a\\fc\\da\\81\\b8\\e7\\fe\\d5\\26\\50\\47\\f3\\1a\\65\\32\\81\\e0\\05\\b8\\4f\\32\\31\\26\\00\\4a\\53\\97\\c2\\c3\\0e\\2e\\a1\\26\\54\\ab\\05\\8e\\56\\2f\\7d\\af\\22\\84\\68\\a5\\8b\\97\\f6\\a4\\fd\\a8\\cc\\75\\41\\96\\86\\fd\\27\\3d\\29\\86\\8d\\7f\\4c\\d4\\8e\\73\\41\\f4\\1e\\e2\\dd\\58\\27\\97\\ce\\9c\\94\\cf\\7a\\04\\2f\\dc\\ed"
+  ))
+
+  (func (export "f64.kahan_sum") (param $$p i32) (param $$n i32) (result f64)
+    (local $$sum f64)
+    (local $$c f64)
+    (local $$t f64)
+    (block $$exit
+      (loop $$top
+        (local.set $$t
+          (f64.sub
+            (f64.sub
+              (local.tee $$sum
+                (f64.add
+                  (local.get $$c)
+                  (local.tee $$t
+                    (f64.sub (f64.load (local.get $$p)) (local.get $$t))
+                  )
+                )
+              )
+              (local.get $$c)
+            )
+            (local.get $$t)
+          )
+        )
+        (local.set $$p (i32.add (local.get $$p) (i32.const 8)))
+        (local.set $$c (local.get $$sum))
+        (br_if $$top (local.tee $$n (i32.add (local.get $$n) (i32.const -1))))
+      )
+    )
+    (local.get $$sum)
+  )
+
+  (func (export "f64.plain_sum") (param $$p i32) (param $$n i32) (result f64)
+    (local $$sum f64)
+    (block $$exit
+      (loop $$top
+        (local.set $$sum (f64.add (local.get $$sum) (f64.load (local.get $$p))))
+        (local.set $$p (i32.add (local.get $$p) (i32.const 8)))
+        (local.set $$n (i32.add (local.get $$n) (i32.const -1)))
+        (br_if $$top (local.get $$n))
+      )
+    )
+    (local.get $$sum)
+  )
+)`);
+
+// ./test/core/float_exprs.wast:1581
+assert_return(
+  () => invoke($62, `f64.kahan_sum`, [0, 256]),
+  [
+    value("f64", 4996401743142033000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1582
+assert_return(
+  () => invoke($62, `f64.plain_sum`, [0, 256]),
+  [
+    value("f64", 4996401743297957600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1586
+let $63 = instantiate(`(module
+  (func (export "f32.no_fold_neg_sub") (param $$x f32) (param $$y f32) (result f32)
+    (f32.neg (f32.sub (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.no_fold_neg_sub") (param $$x f64) (param $$y f64) (result f64)
+    (f64.neg (f64.sub (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1594
+assert_return(
+  () => invoke($63, `f32.no_fold_neg_sub`, [value("f32", -0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1595
+assert_return(
+  () => invoke($63, `f32.no_fold_neg_sub`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1596
+assert_return(
+  () => invoke($63, `f32.no_fold_neg_sub`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1597
+assert_return(
+  () => invoke($63, `f32.no_fold_neg_sub`, [value("f32", 0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1599
+assert_return(
+  () => invoke($63, `f64.no_fold_neg_sub`, [value("f64", -0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1600
+assert_return(
+  () => invoke($63, `f64.no_fold_neg_sub`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1601
+assert_return(
+  () => invoke($63, `f64.no_fold_neg_sub`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1602
+assert_return(
+  () => invoke($63, `f64.no_fold_neg_sub`, [value("f64", 0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1606
+let $64 = instantiate(`(module
+  (func (export "f32.no_fold_neg_add") (param $$x f32) (param $$y f32) (result f32)
+    (f32.neg (f32.add (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.no_fold_neg_add") (param $$x f64) (param $$y f64) (result f64)
+    (f64.neg (f64.add (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1614
+assert_return(
+  () => invoke($64, `f32.no_fold_neg_add`, [value("f32", -0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1615
+assert_return(
+  () => invoke($64, `f32.no_fold_neg_add`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1616
+assert_return(
+  () => invoke($64, `f32.no_fold_neg_add`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1617
+assert_return(
+  () => invoke($64, `f32.no_fold_neg_add`, [value("f32", 0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1619
+assert_return(
+  () => invoke($64, `f64.no_fold_neg_add`, [value("f64", -0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1620
+assert_return(
+  () => invoke($64, `f64.no_fold_neg_add`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1621
+assert_return(
+  () => invoke($64, `f64.no_fold_neg_add`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1622
+assert_return(
+  () => invoke($64, `f64.no_fold_neg_add`, [value("f64", 0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1626
+let $65 = instantiate(`(module
+  (func (export "f32.no_fold_add_neg_neg") (param $$x f32) (param $$y f32) (result f32)
+    (f32.add (f32.neg (local.get $$x)) (f32.neg (local.get $$y))))
+
+  (func (export "f64.no_fold_add_neg_neg") (param $$x f64) (param $$y f64) (result f64)
+    (f64.add (f64.neg (local.get $$x)) (f64.neg (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1634
+assert_return(
+  () => invoke($65, `f32.no_fold_add_neg_neg`, [value("f32", -0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1635
+assert_return(
+  () => invoke($65, `f32.no_fold_add_neg_neg`, [value("f32", 0), value("f32", -0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1636
+assert_return(
+  () => invoke($65, `f32.no_fold_add_neg_neg`, [value("f32", -0), value("f32", 0)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1637
+assert_return(
+  () => invoke($65, `f32.no_fold_add_neg_neg`, [value("f32", 0), value("f32", 0)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1639
+assert_return(
+  () => invoke($65, `f64.no_fold_add_neg_neg`, [value("f64", -0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1640
+assert_return(
+  () => invoke($65, `f64.no_fold_add_neg_neg`, [value("f64", 0), value("f64", -0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1641
+assert_return(
+  () => invoke($65, `f64.no_fold_add_neg_neg`, [value("f64", -0), value("f64", 0)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1642
+assert_return(
+  () => invoke($65, `f64.no_fold_add_neg_neg`, [value("f64", 0), value("f64", 0)]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1646
+let $66 = instantiate(`(module
+  (func (export "f32.no_fold_add_neg") (param $$x f32) (result f32)
+    (f32.add (f32.neg (local.get $$x)) (local.get $$x)))
+
+  (func (export "f64.no_fold_add_neg") (param $$x f64) (result f64)
+    (f64.add (f64.neg (local.get $$x)) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:1654
+assert_return(() => invoke($66, `f32.no_fold_add_neg`, [value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1655
+assert_return(() => invoke($66, `f32.no_fold_add_neg`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1656
+assert_return(() => invoke($66, `f32.no_fold_add_neg`, [value("f32", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:1657
+assert_return(() => invoke($66, `f32.no_fold_add_neg`, [value("f32", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:1659
+assert_return(() => invoke($66, `f64.no_fold_add_neg`, [value("f64", 0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1660
+assert_return(() => invoke($66, `f64.no_fold_add_neg`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1661
+assert_return(() => invoke($66, `f64.no_fold_add_neg`, [value("f64", Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:1662
+assert_return(() => invoke($66, `f64.no_fold_add_neg`, [value("f64", -Infinity)]), [`canonical_nan`]);
+
+// ./test/core/float_exprs.wast:1666
+let $67 = instantiate(`(module
+  (func (export "f32.no_fold_6x_via_add") (param $$x f32) (result f32)
+    (f32.add (f32.add (f32.add (f32.add (f32.add
+    (local.get $$x)
+    (local.get $$x)) (local.get $$x)) (local.get $$x))
+    (local.get $$x)) (local.get $$x)))
+
+  (func (export "f64.no_fold_6x_via_add") (param $$x f64) (result f64)
+    (f64.add (f64.add (f64.add (f64.add (f64.add
+    (local.get $$x)
+    (local.get $$x)) (local.get $$x)) (local.get $$x))
+    (local.get $$x)) (local.get $$x)))
+)`);
+
+// ./test/core/float_exprs.wast:1680
+assert_return(
+  () => invoke($67, `f32.no_fold_6x_via_add`, [
+    value("f32", -855513700000000000000000000000),
+  ]),
+  [value("f32", -5133083000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1681
+assert_return(
+  () => invoke($67, `f32.no_fold_6x_via_add`, [
+    value("f32", -0.00000000000000000000001209506),
+  ]),
+  [value("f32", -0.00000000000000000000007257036)],
+);
+
+// ./test/core/float_exprs.wast:1682
+assert_return(
+  () => invoke($67, `f32.no_fold_6x_via_add`, [
+    value("f32", 0.000000000000000000000006642689),
+  ]),
+  [value("f32", 0.000000000000000000000039856134)],
+);
+
+// ./test/core/float_exprs.wast:1683
+assert_return(
+  () => invoke($67, `f32.no_fold_6x_via_add`, [value("f32", -0.0000000006147346)]),
+  [value("f32", -0.0000000036884074)],
+);
+
+// ./test/core/float_exprs.wast:1684
+assert_return(
+  () => invoke($67, `f32.no_fold_6x_via_add`, [
+    value("f32", -1209858100000000000000000),
+  ]),
+  [value("f32", -7259148300000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1686
+assert_return(
+  () => invoke($67, `f64.no_fold_6x_via_add`, [value("f64", -351704490602771400000)]),
+  [value("f64", -2110226943616628600000)],
+);
+
+// ./test/core/float_exprs.wast:1687
+assert_return(
+  () => invoke($67, `f64.no_fold_6x_via_add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014824294109868734),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008894576465921239),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1688
+assert_return(
+  () => invoke($67, `f64.no_fold_6x_via_add`, [
+    value("f64", -7484567838781003000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -44907407032686014000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1689
+assert_return(
+  () => invoke($67, `f64.no_fold_6x_via_add`, [
+    value("f64", 17277868192936067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 103667209157616410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1690
+assert_return(
+  () => invoke($67, `f64.no_fold_6x_via_add`, [
+    value("f64", -43116397525195610000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -258698385151173640000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1695
+let $68 = instantiate(`(module
+  (func (export "f32.no_fold_div_div") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.div (f32.div (local.get $$x) (local.get $$y)) (local.get $$z)))
+
+  (func (export "f64.no_fold_div_div") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.div (f64.div (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:1703
+assert_return(
+  () => invoke($68, `f32.no_fold_div_div`, [
+    value("f32", -593847530000000000000000),
+    value("f32", -0.000030265672),
+    value("f32", -1584.8682),
+  ]),
+  [value("f32", -12380309000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1704
+assert_return(
+  () => invoke($68, `f32.no_fold_div_div`, [
+    value("f32", 0.0000000000000000000015438962),
+    value("f32", 2533429300000000000000000000000000),
+    value("f32", -0.00000000000000000000000000000000026844783),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1705
+assert_return(
+  () => invoke($68, `f32.no_fold_div_div`, [
+    value("f32", 13417423000000),
+    value("f32", 0.000000000000000000000000000000029339205),
+    value("f32", 76386374000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1706
+assert_return(
+  () => invoke($68, `f32.no_fold_div_div`, [
+    value("f32", -0.00010776529),
+    value("f32", -34220943000000000000000000000000000000),
+    value("f32", -0.00000000000016562324),
+  ]),
+  [value("f32", -0.000000000000000000000000000019011327)],
+);
+
+// ./test/core/float_exprs.wast:1707
+assert_return(
+  () => invoke($68, `f32.no_fold_div_div`, [
+    value("f32", 130582500000000),
+    value("f32", 96245350000000000),
+    value("f32", -41461545000000000000000000000000000000),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000032723)],
+);
+
+// ./test/core/float_exprs.wast:1709
+assert_return(
+  () => invoke($68, `f64.no_fold_div_div`, [
+    value("f64", 477762874671014340000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 102786720420404010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000718999894988884),
+  ]),
+  [
+    value("f64", -64646730118787990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1710
+assert_return(
+  () => invoke($68, `f64.no_fold_div_div`, [
+    value("f64", -21790236783875714000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000028324436844616576),
+    value("f64", 186110768259868700000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -41336068079920670000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1711
+assert_return(
+  () => invoke($68, `f64.no_fold_div_div`, [
+    value("f64", -7.287619347826683),
+    value("f64", -13467607316739855000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 2462719007013688000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000219725454),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1712
+assert_return(
+  () => invoke($68, `f64.no_fold_div_div`, [
+    value("f64", -286552397862963300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010211980370639414),
+    value("f64", 28764586483324010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1713
+assert_return(
+  () => invoke($68, `f64.no_fold_div_div`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009525735602663874),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000050233948816631796),
+    value("f64", -0.0000000000000000000000000000000000000000028304570228221077),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000006699534674970116),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1719
+let $69 = instantiate(`(module
+  (func (export "f32.no_fold_mul_divs") (param $$x f32) (param $$y f32) (param $$z f32) (param $$w f32) (result f32)
+    (f32.mul (f32.div (local.get $$x) (local.get $$y)) (f32.div (local.get $$z) (local.get $$w))))
+
+  (func (export "f64.no_fold_mul_divs") (param $$x f64) (param $$y f64) (param $$z f64) (param $$w f64) (result f64)
+    (f64.mul (f64.div (local.get $$x) (local.get $$y)) (f64.div (local.get $$z) (local.get $$w))))
+)`);
+
+// ./test/core/float_exprs.wast:1727
+assert_return(
+  () => invoke($69, `f32.no_fold_mul_divs`, [
+    value("f32", -0.0000000000000000000000000000000027234733),
+    value("f32", 0.0000000000000000000000000003897843),
+    value("f32", 0.000000000000000000000000004847123),
+    value("f32", -25.357775),
+  ]),
+  [value("f32", 0.0000000000000000000000000000000013355855)],
+);
+
+// ./test/core/float_exprs.wast:1728
+assert_return(
+  () => invoke($69, `f32.no_fold_mul_divs`, [
+    value("f32", -5372844000000000000000000000000),
+    value("f32", 38340910),
+    value("f32", 0.000014973162),
+    value("f32", 0.19213825),
+  ]),
+  [value("f32", -10920475000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1729
+assert_return(
+  () => invoke($69, `f32.no_fold_mul_divs`, [
+    value("f32", -16085042000),
+    value("f32", -1092920200000),
+    value("f32", -869606000),
+    value("f32", -1201.206),
+  ]),
+  [value("f32", 10654.639)],
+);
+
+// ./test/core/float_exprs.wast:1730
+assert_return(
+  () => invoke($69, `f32.no_fold_mul_divs`, [
+    value("f32", -1271223140000000000000000000000000),
+    value("f32", 0.00000000010768114),
+    value("f32", 0.000018576271),
+    value("f32", 492686200000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1731
+assert_return(
+  () => invoke($69, `f32.no_fold_mul_divs`, [
+    value("f32", 0.00000000000000013783864),
+    value("f32", -0.000000000000000000065046285),
+    value("f32", 0.00000000000000000000000000068167684),
+    value("f32", 0.000000000022892627),
+  ]),
+  [value("f32", -0.000000000000063100295)],
+);
+
+// ./test/core/float_exprs.wast:1733
+assert_return(
+  () => invoke($69, `f64.no_fold_mul_divs`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003466499805233369),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004045567512248635),
+    value("f64", -646234107060759200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 100455895333540740000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -55.12215321310017)],
+);
+
+// ./test/core/float_exprs.wast:1734
+assert_return(
+  () => invoke($69, `f64.no_fold_mul_divs`, [
+    value("f64", -50548839076363250000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022223781649976275),
+    value("f64", -15029790371100852000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -699412375953812100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1735
+assert_return(
+  () => invoke($69, `f64.no_fold_mul_divs`, [
+    value("f64", -836111653634494700000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -10029528876067567000000000000000000000000000000000000000000),
+    value("f64", -0.0000000000000000000000000000000000000000012867801766038772),
+    value("f64", -42230277746883753000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002540178100556387),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1736
+assert_return(
+  () => invoke($69, `f64.no_fold_mul_divs`, [
+    value("f64", -1202003211641119300000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004667409771338769),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010888652376540085),
+    value("f64", 18334948666517216000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1737
+assert_return(
+  () => invoke($69, `f64.no_fold_mul_divs`, [
+    value("f64", 0.000006331839568840419),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000005544474241905778),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000027822472480359097),
+    value("f64", -14419321081893022000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022035374770746518),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1741
+let $70 = instantiate(`(module
+  (func (export "f32.no_fold_add_divs") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.add (f32.div (local.get $$x) (local.get $$z)) (f32.div (local.get $$y) (local.get $$z))))
+
+  (func (export "f64.no_fold_add_divs") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.add (f64.div (local.get $$x) (local.get $$z)) (f64.div (local.get $$y) (local.get $$z))))
+)`);
+
+// ./test/core/float_exprs.wast:1749
+assert_return(
+  () => invoke($70, `f32.no_fold_add_divs`, [
+    value("f32", 377.3689),
+    value("f32", -0.040118184),
+    value("f32", -136292990000000000000000000000000000000),
+  ]),
+  [value("f32", -0.0000000000000000000000000000000000027685121)],
+);
+
+// ./test/core/float_exprs.wast:1750
+assert_return(
+  () => invoke($70, `f32.no_fold_add_divs`, [
+    value("f32", -0.00000000000000000018234023),
+    value("f32", -0.0000000000000033970288),
+    value("f32", -170996700000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000019867115)],
+);
+
+// ./test/core/float_exprs.wast:1751
+assert_return(
+  () => invoke($70, `f32.no_fold_add_divs`, [
+    value("f32", -0.000000000000019672638),
+    value("f32", 0.00000000000000000006414099),
+    value("f32", -541989070000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000036296997)],
+);
+
+// ./test/core/float_exprs.wast:1752
+assert_return(
+  () => invoke($70, `f32.no_fold_add_divs`, [
+    value("f32", -0.0000000000000000000000000000004038506),
+    value("f32", 0.000000000000000000000000000003848228),
+    value("f32", -345237200000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1753
+assert_return(
+  () => invoke($70, `f32.no_fold_add_divs`, [
+    value("f32", 0.0010934415),
+    value("f32", 0.20703124),
+    value("f32", 0.00000000000000000000000000000000000013509784),
+  ]),
+  [value("f32", 1540547700000000000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1755
+assert_return(
+  () => invoke($70, `f64.no_fold_add_divs`, [
+    value("f64", -4917019432143760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 68132156322019020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 26125410100237784000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024196801752520584),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1756
+assert_return(
+  () => invoke($70, `f64.no_fold_add_divs`, [
+    value("f64", -10206467953224550),
+    value("f64", 63.422616671746226),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016024747869814892),
+  ]),
+  [
+    value("f64", 6369190976445851000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1757
+assert_return(
+  () => invoke($70, `f64.no_fold_add_divs`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015270569633109837),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025755503329232514),
+    value("f64", 58826939164214920000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1758
+assert_return(
+  () => invoke($70, `f64.no_fold_add_divs`, [
+    value("f64", 26667964874394640000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -2131569252493657800000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.000000000000000000000000000000000000012377004518680012),
+  ]),
+  [
+    value("f64", -172217969324625340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1759
+assert_return(
+  () => invoke($70, `f64.no_fold_add_divs`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012952888377288216),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005808769259900048),
+    value("f64", 0.0000000000000000000016745741699443756),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007735034106987796),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1763
+let $71 = instantiate(`(module
+  (func (export "f32.no_fold_sqrt_square") (param $$x f32) (result f32)
+    (f32.sqrt (f32.mul (local.get $$x) (local.get $$x))))
+
+  (func (export "f64.no_fold_sqrt_square") (param $$x f64) (result f64)
+    (f64.sqrt (f64.mul (local.get $$x) (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:1771
+assert_return(
+  () => invoke($71, `f32.no_fold_sqrt_square`, [
+    value("f32", -0.00000000000000000001846),
+  ]),
+  [value("f32", 0.00000000000000000001846001)],
+);
+
+// ./test/core/float_exprs.wast:1772
+assert_return(
+  () => invoke($71, `f32.no_fold_sqrt_square`, [
+    value("f32", -0.00000000000000000000017907473),
+  ]),
+  [value("f32", 0.00000000000000000000017952678)],
+);
+
+// ./test/core/float_exprs.wast:1773
+assert_return(
+  () => invoke($71, `f32.no_fold_sqrt_square`, [
+    value("f32", -0.00000000000000000000079120785),
+  ]),
+  [value("f32", 0.000000000000000000000791442)],
+);
+
+// ./test/core/float_exprs.wast:1774
+assert_return(
+  () => invoke($71, `f32.no_fold_sqrt_square`, [
+    value("f32", 0.000000000000000000000000018012938),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1775
+assert_return(
+  () => invoke($71, `f32.no_fold_sqrt_square`, [
+    value("f32", 610501970000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1777
+assert_return(
+  () => invoke($71, `f64.no_fold_sqrt_square`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006209297167747496),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006209299542179727),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1778
+assert_return(
+  () => invoke($71, `f64.no_fold_sqrt_square`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024211175303738945),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024211175303738937),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1779
+assert_return(
+  () => invoke($71, `f64.no_fold_sqrt_square`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016460687611875645),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016460687611532367),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1780
+assert_return(
+  () => invoke($71, `f64.no_fold_sqrt_square`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003797811613378828),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:1781
+assert_return(
+  () => invoke($71, `f64.no_fold_sqrt_square`, [
+    value("f64", 815808428460559200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1785
+let $72 = instantiate(`(module
+  (func (export "f32.no_fold_mul_sqrts") (param $$x f32) (param $$y f32) (result f32)
+    (f32.mul (f32.sqrt (local.get $$x)) (f32.sqrt (local.get $$y))))
+
+  (func (export "f64.no_fold_mul_sqrts") (param $$x f64) (param $$y f64) (result f64)
+    (f64.mul (f64.sqrt (local.get $$x)) (f64.sqrt (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1793
+assert_return(
+  () => invoke($72, `f32.no_fold_mul_sqrts`, [
+    value("f32", 0.000000000000000000000000000000000000043885047),
+    value("f32", -0.00000000000000000000000011867334),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:1794
+assert_return(
+  () => invoke($72, `f32.no_fold_mul_sqrts`, [
+    value("f32", 0.00000000000000000000000000025365908),
+    value("f32", 0.00000000041320675),
+  ]),
+  [value("f32", 0.00000000000000000032374932)],
+);
+
+// ./test/core/float_exprs.wast:1795
+assert_return(
+  () => invoke($72, `f32.no_fold_mul_sqrts`, [
+    value("f32", 0.0000000000000000000000000042144832),
+    value("f32", 97.249115),
+  ]),
+  [value("f32", 0.00000000000064019905)],
+);
+
+// ./test/core/float_exprs.wast:1796
+assert_return(
+  () => invoke($72, `f32.no_fold_mul_sqrts`, [
+    value("f32", 3724076300000000000000000000000),
+    value("f32", 0.002944908),
+  ]),
+  [value("f32", 104723750000000)],
+);
+
+// ./test/core/float_exprs.wast:1797
+assert_return(
+  () => invoke($72, `f32.no_fold_mul_sqrts`, [
+    value("f32", 0.00000000000000001866056),
+    value("f32", 0.002111261),
+  ]),
+  [value("f32", 0.00000000019848755)],
+);
+
+// ./test/core/float_exprs.wast:1799
+assert_return(
+  () => invoke($72, `f64.no_fold_mul_sqrts`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012742064369772862),
+    value("f64", -0.006829962938197246),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:1800
+assert_return(
+  () => invoke($72, `f64.no_fold_mul_sqrts`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000037082569269527534),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047183002857015043),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041829020688865954),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1801
+assert_return(
+  () => invoke($72, `f64.no_fold_mul_sqrts`, [
+    value("f64", 0.000000000000000000000000002329359505918655),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020743399642806364),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021981545701574452),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1802
+assert_return(
+  () => invoke($72, `f64.no_fold_mul_sqrts`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010541899336289437),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000598123819872803),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002511047809129887),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1803
+assert_return(
+  () => invoke($72, `f64.no_fold_mul_sqrts`, [
+    value("f64", 25589482.717358638),
+    value("f64", 39138912071199020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 1000771959050695500000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1807
+let $73 = instantiate(`(module
+  (func (export "f32.no_fold_div_sqrts") (param $$x f32) (param $$y f32) (result f32)
+    (f32.div (f32.sqrt (local.get $$x)) (f32.sqrt (local.get $$y))))
+
+  (func (export "f64.no_fold_div_sqrts") (param $$x f64) (param $$y f64) (result f64)
+    (f64.div (f64.sqrt (local.get $$x)) (f64.sqrt (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:1815
+assert_return(
+  () => invoke($73, `f32.no_fold_div_sqrts`, [
+    value("f32", -58545012),
+    value("f32", -0.000000000000000006443773),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:1816
+assert_return(
+  () => invoke($73, `f32.no_fold_div_sqrts`, [
+    value("f32", 7407384000),
+    value("f32", 209778930),
+  ]),
+  [value("f32", 5.9422584)],
+);
+
+// ./test/core/float_exprs.wast:1817
+assert_return(
+  () => invoke($73, `f32.no_fold_div_sqrts`, [
+    value("f32", 0.0000000000000000000000000000000000013764126),
+    value("f32", 54692.9),
+  ]),
+  [value("f32", 0.0000000000000000000050165927)],
+);
+
+// ./test/core/float_exprs.wast:1818
+assert_return(
+  () => invoke($73, `f32.no_fold_div_sqrts`, [
+    value("f32", 979288960000000000),
+    value("f32", 0.0000000012643552),
+  ]),
+  [value("f32", 27830490000000)],
+);
+
+// ./test/core/float_exprs.wast:1819
+assert_return(
+  () => invoke($73, `f32.no_fold_div_sqrts`, [
+    value("f32", 0.00000000000000000000000000000000029141283),
+    value("f32", 0.00000000000000000000000000000017928174),
+  ]),
+  [value("f32", 0.04031682)],
+);
+
+// ./test/core/float_exprs.wast:1821
+assert_return(
+  () => invoke($73, `f64.no_fold_div_sqrts`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012206137319883022),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000008209583449676083),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_exprs.wast:1822
+assert_return(
+  () => invoke($73, `f64.no_fold_div_sqrts`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033818852462305824),
+    value("f64", 7655783976315048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021017671425665687),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1823
+assert_return(
+  () => invoke($73, `f64.no_fold_div_sqrts`, [
+    value("f64", 45963335670647510000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000023932467846883046),
+  ]),
+  [
+    value("f64", 138583660172663150000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1824
+assert_return(
+  () => invoke($73, `f64.no_fold_div_sqrts`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025327340978668086),
+    value("f64", 4475305129961258000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023789399141325018),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1825
+assert_return(
+  () => invoke($73, `f64.no_fold_div_sqrts`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005103070160197939),
+    value("f64", 460157669098082500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010530826009924495),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1829
+let $74 = instantiate(`(module
+  (func (export "f32.no_fold_mul_sqrt_div") (param $$x f32) (param $$y f32) (result f32)
+    (f32.div (f32.mul (local.get $$x) (f32.sqrt (local.get $$y))) (local.get $$y)))
+
+  (func (export "f64.no_fold_mul_sqrt_div") (param $$x f64) (param $$y f64) (result f64)
+    (f64.div (f64.mul (local.get $$x) (f64.sqrt (local.get $$y))) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:1837
+assert_return(
+  () => invoke($74, `f32.no_fold_mul_sqrt_div`, [
+    value("f32", -4728556800000000000000000),
+    value("f32", 8677282000000000000000000000),
+  ]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1838
+assert_return(
+  () => invoke($74, `f32.no_fold_mul_sqrt_div`, [
+    value("f32", -0.0000000000000000000000000000000000011776882),
+    value("f32", 0.000000000000000000000000000009805153),
+  ]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:1839
+assert_return(
+  () => invoke($74, `f32.no_fold_mul_sqrt_div`, [
+    value("f32", 816717060),
+    value("f32", 0.000000000000000000000000000000000000003323171),
+  ]),
+  [value("f32", 14167568000000000000000000000)],
+);
+
+// ./test/core/float_exprs.wast:1840
+assert_return(
+  () => invoke($74, `f32.no_fold_mul_sqrt_div`, [
+    value("f32", -11932267000000),
+    value("f32", 8637067000000000000000000000000000),
+  ]),
+  [value("f32", -0.00012839255)],
+);
+
+// ./test/core/float_exprs.wast:1841
+assert_return(
+  () => invoke($74, `f32.no_fold_mul_sqrt_div`, [
+    value("f32", -401.0235),
+    value("f32", 134.33022),
+  ]),
+  [value("f32", -34.600548)],
+);
+
+// ./test/core/float_exprs.wast:1843
+assert_return(
+  () => invoke($74, `f64.no_fold_mul_sqrt_div`, [
+    value("f64", 1468134622910490500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 2466074582285183000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_exprs.wast:1844
+assert_return(
+  () => invoke($74, `f64.no_fold_mul_sqrt_div`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017254022016758028),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055835540747130025),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_exprs.wast:1845
+assert_return(
+  () => invoke($74, `f64.no_fold_mul_sqrt_div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016812810256029166),
+    value("f64", 7362783602442129000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006196112486187196),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1846
+assert_return(
+  () => invoke($74, `f64.no_fold_mul_sqrt_div`, [
+    value("f64", -10605483729939836000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000622591783694072),
+  ]),
+  [
+    value("f64", -42503900822233765000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1847
+assert_return(
+  () => invoke($74, `f64.no_fold_mul_sqrt_div`, [
+    value("f64", 26336349695373093000000000000000),
+    value("f64", 30791413285853300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004746142447510695),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1852
+let $75 = instantiate(`(module
+  (func (export "f32.no_flush_intermediate_subnormal") (param $$x f32) (param $$y f32) (param $$z f32) (result f32)
+    (f32.mul (f32.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+
+  (func (export "f64.no_flush_intermediate_subnormal") (param $$x f64) (param $$y f64) (param $$z f64) (result f64)
+    (f64.mul (f64.mul (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:1860
+assert_return(
+  () => invoke($75, `f32.no_flush_intermediate_subnormal`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.00000011920929),
+    value("f32", 8388608),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/float_exprs.wast:1861
+assert_return(
+  () => invoke($75, `f64.no_flush_intermediate_subnormal`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.0000000000000002220446049250313),
+    value("f64", 4503599627370496),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/float_exprs.wast:1866
+let $76 = instantiate(`(module
+  (func (export "f32.recoding_eq") (param $$x f32) (param $$y f32) (result i32)
+    (f32.eq (f32.mul (local.get $$x) (local.get $$y)) (local.get $$x)))
+
+  (func (export "f32.recoding_le") (param $$x f32) (param $$y f32) (result i32)
+    (f32.le (f32.mul (local.get $$x) (local.get $$y)) (local.get $$x)))
+
+  (func (export "f32.recoding_lt") (param $$x f32) (param $$y f32) (result i32)
+    (f32.lt (f32.mul (local.get $$x) (local.get $$y)) (local.get $$x)))
+
+  (func (export "f64.recoding_eq") (param $$x f64) (param $$y f64) (result i32)
+    (f64.eq (f64.mul (local.get $$x) (local.get $$y)) (local.get $$x)))
+
+  (func (export "f64.recoding_le") (param $$x f64) (param $$y f64) (result i32)
+    (f64.le (f64.mul (local.get $$x) (local.get $$y)) (local.get $$x)))
+
+  (func (export "f64.recoding_lt") (param $$x f64) (param $$y f64) (result i32)
+    (f64.lt (f64.mul (local.get $$x) (local.get $$y)) (local.get $$x)))
+
+  (func (export "recoding_demote") (param $$x f64) (param $$y f32) (result f32)
+    (f32.mul (f32.demote_f64 (local.get $$x)) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:1889
+assert_return(
+  () => invoke($76, `f32.recoding_eq`, [value("f32", -Infinity), value("f32", 3)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1890
+assert_return(
+  () => invoke($76, `f32.recoding_le`, [value("f32", -Infinity), value("f32", 3)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1891
+assert_return(
+  () => invoke($76, `f32.recoding_lt`, [value("f32", -Infinity), value("f32", 3)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1893
+assert_return(
+  () => invoke($76, `f32.recoding_eq`, [value("f32", 0), value("f32", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1894
+assert_return(
+  () => invoke($76, `f32.recoding_le`, [value("f32", 0), value("f32", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1895
+assert_return(
+  () => invoke($76, `f32.recoding_lt`, [value("f32", 0), value("f32", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1897
+assert_return(
+  () => invoke($76, `f64.recoding_eq`, [value("f64", -Infinity), value("f64", 3)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1898
+assert_return(
+  () => invoke($76, `f64.recoding_le`, [value("f64", -Infinity), value("f64", 3)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1899
+assert_return(
+  () => invoke($76, `f64.recoding_lt`, [value("f64", -Infinity), value("f64", 3)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1901
+assert_return(
+  () => invoke($76, `f64.recoding_eq`, [value("f64", 0), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1902
+assert_return(
+  () => invoke($76, `f64.recoding_le`, [value("f64", 0), value("f64", 1)]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1903
+assert_return(
+  () => invoke($76, `f64.recoding_lt`, [value("f64", 0), value("f64", 1)]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:1905
+assert_return(
+  () => invoke($76, `recoding_demote`, [
+    value("f64", 0.00000000000000000000000000000000000000023860049081905093),
+    value("f32", 1221),
+  ]),
+  [value("f32", 0.0000000000000000000000000000000000002913312)],
+);
+
+// ./test/core/float_exprs.wast:1910
+let $77 = instantiate(`(module
+  (func (export "f32.no_extended_precision_div") (param $$x f32) (param $$y f32) (param $$z f32) (result i32)
+    (f32.eq (f32.div (local.get $$x) (local.get $$y)) (local.get $$z)))
+
+  (func (export "f64.no_extended_precision_div") (param $$x f64) (param $$y f64) (param $$z f64) (result i32)
+    (f64.eq (f64.div (local.get $$x) (local.get $$y)) (local.get $$z)))
+)`);
+
+// ./test/core/float_exprs.wast:1918
+assert_return(
+  () => invoke($77, `f32.no_extended_precision_div`, [
+    value("f32", 3),
+    value("f32", 7),
+    value("f32", 0.42857143),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1919
+assert_return(
+  () => invoke($77, `f64.no_extended_precision_div`, [
+    value("f64", 3),
+    value("f64", 7),
+    value("f64", 0.42857142857142855),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:1926
+let $78 = instantiate(`(module
+  (func (export "f32.no_distribute_exact") (param $$x f32) (result f32)
+    (f32.add (f32.mul (f32.const -8.0) (local.get $$x)) (f32.mul (f32.const 8.0) (local.get $$x))))
+
+  (func (export "f64.no_distribute_exact") (param $$x f64) (result f64)
+    (f64.add (f64.mul (f64.const -8.0) (local.get $$x)) (f64.mul (f64.const 8.0) (local.get $$x))))
+)`);
+
+// ./test/core/float_exprs.wast:1934
+assert_return(() => invoke($78, `f32.no_distribute_exact`, [value("f32", -0)]), [value("f32", 0)]);
+
+// ./test/core/float_exprs.wast:1935
+assert_return(() => invoke($78, `f64.no_distribute_exact`, [value("f64", -0)]), [value("f64", 0)]);
+
+// ./test/core/float_exprs.wast:1940
+let $79 = instantiate(`(module
+  (func (export "f32.sqrt") (param f32) (result f32)
+    (f32.sqrt (local.get 0)))
+
+  (func (export "f32.xkcd_sqrt_2") (param f32) (param f32) (param f32) (param f32) (result f32)
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (f32.sub (local.get 3) (local.get 2)))))
+
+  (func (export "f32.xkcd_sqrt_3") (param f32) (param f32) (param f32) (result f32)
+    (f32.div (f32.mul (local.get 0) (local.get 1)) (local.get 2)))
+
+  (func (export "f32.xkcd_sqrt_5") (param f32) (param f32) (param f32) (result f32)
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (local.get 0))))
+
+  (func (export "f32.xkcd_better_sqrt_5") (param f32) (param f32) (param f32) (param f32) (result f32)
+    (f32.div (f32.add (local.get 0) (f32.mul (local.get 1) (local.get 2))) (f32.sub (local.get 3) (f32.mul (local.get 1) (local.get 2)))))
+
+  (func (export "f64.sqrt") (param f64) (result f64)
+    (f64.sqrt (local.get 0)))
+
+  (func (export "f64.xkcd_sqrt_2") (param f64) (param f64) (param f64) (param f64) (result f64)
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (f64.sub (local.get 3) (local.get 2)))))
+
+  (func (export "f64.xkcd_sqrt_3") (param f64) (param f64) (param f64) (result f64)
+    (f64.div (f64.mul (local.get 0) (local.get 1)) (local.get 2)))
+
+  (func (export "f64.xkcd_sqrt_5") (param f64) (param f64) (param f64) (result f64)
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (local.get 0))))
+
+  (func (export "f64.xkcd_better_sqrt_5") (param f64) (param f64) (param f64) (param f64) (result f64)
+    (f64.div (f64.add (local.get 0) (f64.mul (local.get 1) (local.get 2))) (f64.sub (local.get 3) (f64.mul (local.get 1) (local.get 2)))))
+)`);
+
+// ./test/core/float_exprs.wast:1972
+assert_return(() => invoke($79, `f32.sqrt`, [value("f32", 2)]), [value("f32", 1.4142135)]);
+
+// ./test/core/float_exprs.wast:1973
+assert_return(
+  () => invoke($79, `f32.xkcd_sqrt_2`, [
+    value("f32", 3),
+    value("f32", 5),
+    value("f32", 3.1415927),
+    value("f32", 7),
+  ]),
+  [value("f32", 1.4142201)],
+);
+
+// ./test/core/float_exprs.wast:1974
+assert_return(() => invoke($79, `f32.sqrt`, [value("f32", 3)]), [value("f32", 1.7320508)]);
+
+// ./test/core/float_exprs.wast:1975
+assert_return(
+  () => invoke($79, `f32.xkcd_sqrt_3`, [
+    value("f32", 2),
+    value("f32", 2.7182817),
+    value("f32", 3.1415927),
+  ]),
+  [value("f32", 1.7305119)],
+);
+
+// ./test/core/float_exprs.wast:1976
+assert_return(() => invoke($79, `f32.sqrt`, [value("f32", 5)]), [value("f32", 2.236068)]);
+
+// ./test/core/float_exprs.wast:1977
+assert_return(
+  () => invoke($79, `f32.xkcd_sqrt_5`, [
+    value("f32", 2),
+    value("f32", 2.7182817),
+    value("f32", 3),
+  ]),
+  [value("f32", 2.2357588)],
+);
+
+// ./test/core/float_exprs.wast:1978
+assert_return(
+  () => invoke($79, `f32.xkcd_better_sqrt_5`, [
+    value("f32", 13),
+    value("f32", 4),
+    value("f32", 3.1415927),
+    value("f32", 24),
+  ]),
+  [value("f32", 2.236068)],
+);
+
+// ./test/core/float_exprs.wast:1980
+assert_return(() => invoke($79, `f64.sqrt`, [value("f64", 2)]), [value("f64", 1.4142135623730951)]);
+
+// ./test/core/float_exprs.wast:1981
+assert_return(
+  () => invoke($79, `f64.xkcd_sqrt_2`, [
+    value("f64", 3),
+    value("f64", 5),
+    value("f64", 3.141592653589793),
+    value("f64", 7),
+  ]),
+  [value("f64", 1.4142200580539208)],
+);
+
+// ./test/core/float_exprs.wast:1982
+assert_return(() => invoke($79, `f64.sqrt`, [value("f64", 3)]), [value("f64", 1.7320508075688772)]);
+
+// ./test/core/float_exprs.wast:1983
+assert_return(
+  () => invoke($79, `f64.xkcd_sqrt_3`, [
+    value("f64", 2),
+    value("f64", 2.718281828459045),
+    value("f64", 3.141592653589793),
+  ]),
+  [value("f64", 1.7305119588645301)],
+);
+
+// ./test/core/float_exprs.wast:1984
+assert_return(() => invoke($79, `f64.sqrt`, [value("f64", 5)]), [value("f64", 2.23606797749979)]);
+
+// ./test/core/float_exprs.wast:1985
+assert_return(
+  () => invoke($79, `f64.xkcd_sqrt_5`, [
+    value("f64", 2),
+    value("f64", 2.718281828459045),
+    value("f64", 3),
+  ]),
+  [value("f64", 2.2357588823428847)],
+);
+
+// ./test/core/float_exprs.wast:1986
+assert_return(
+  () => invoke($79, `f64.xkcd_better_sqrt_5`, [
+    value("f64", 13),
+    value("f64", 4),
+    value("f64", 3.141592653589793),
+    value("f64", 24),
+  ]),
+  [value("f64", 2.2360678094452893)],
+);
+
+// ./test/core/float_exprs.wast:1991
+let $80 = instantiate(`(module
+  (func (export "f32.compute_radix") (param $$0 f32) (param $$1 f32) (result f32)
+    (loop $$label$$0
+      (br_if $$label$$0
+        (f32.eq
+          (f32.add
+            (f32.sub
+              (f32.add
+                (local.tee $$0 (f32.add (local.get $$0) (local.get $$0)))
+                (f32.const 1)
+              )
+              (local.get $$0)
+            )
+            (f32.const -1)
+          )
+          (f32.const 0)
+        )
+      )
+    )
+    (loop $$label$$2
+      (br_if $$label$$2
+        (f32.ne
+          (f32.sub
+            (f32.sub
+              (f32.add
+                (local.get $$0)
+                (local.tee $$1 (f32.add (local.get $$1) (f32.const 1)))
+              )
+              (local.get $$0)
+            )
+            (local.get $$1)
+          )
+          (f32.const 0)
+        )
+      )
+    )
+    (local.get $$1)
+  )
+
+  (func (export "f64.compute_radix") (param $$0 f64) (param $$1 f64) (result f64)
+    (loop $$label$$0
+      (br_if $$label$$0
+        (f64.eq
+          (f64.add
+            (f64.sub
+              (f64.add
+                (local.tee $$0 (f64.add (local.get $$0) (local.get $$0)))
+                (f64.const 1)
+              )
+              (local.get $$0)
+            )
+            (f64.const -1)
+          )
+          (f64.const 0)
+        )
+      )
+    )
+    (loop $$label$$2
+      (br_if $$label$$2
+        (f64.ne
+          (f64.sub
+            (f64.sub
+              (f64.add
+                (local.get $$0)
+                (local.tee $$1 (f64.add (local.get $$1) (f64.const 1)))
+              )
+              (local.get $$0)
+            )
+            (local.get $$1)
+          )
+          (f64.const 0)
+        )
+      )
+    )
+    (local.get $$1)
+  )
+)`);
+
+// ./test/core/float_exprs.wast:2069
+assert_return(
+  () => invoke($80, `f32.compute_radix`, [value("f32", 1), value("f32", 1)]),
+  [value("f32", 2)],
+);
+
+// ./test/core/float_exprs.wast:2070
+assert_return(
+  () => invoke($80, `f64.compute_radix`, [value("f64", 1), value("f64", 1)]),
+  [value("f64", 2)],
+);
+
+// ./test/core/float_exprs.wast:2075
+let $81 = instantiate(`(module
+  (func (export "f32.no_fold_sub1_mul_add") (param $$x f32) (param $$y f32) (result f32)
+    (f32.add (f32.mul (f32.sub (local.get $$x) (f32.const 1.0)) (local.get $$y)) (local.get $$y)))
+
+  (func (export "f64.no_fold_sub1_mul_add") (param $$x f64) (param $$y f64) (result f64)
+    (f64.add (f64.mul (f64.sub (local.get $$x) (f64.const 1.0)) (local.get $$y)) (local.get $$y)))
+)`);
+
+// ./test/core/float_exprs.wast:2083
+assert_return(
+  () => invoke($81, `f32.no_fold_sub1_mul_add`, [
+    value("f32", 0.00000000023283064),
+    value("f32", 1),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2084
+assert_return(
+  () => invoke($81, `f64.no_fold_sub1_mul_add`, [
+    value("f64", 0.00000000000000000005421010862427522),
+    value("f64", 1),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:2089
+let $82 = instantiate(`(module
+  (func (export "f32.no_fold_add_le_monotonicity") (param $$x f32) (param $$y f32) (param $$z f32) (result i32)
+    (f32.le (f32.add (local.get $$x) (local.get $$z)) (f32.add (local.get $$y) (local.get $$z))))
+
+  (func (export "f32.no_fold_add_ge_monotonicity") (param $$x f32) (param $$y f32) (param $$z f32) (result i32)
+    (f32.ge (f32.add (local.get $$x) (local.get $$z)) (f32.add (local.get $$y) (local.get $$z))))
+
+  (func (export "f64.no_fold_add_le_monotonicity") (param $$x f64) (param $$y f64) (param $$z f64) (result i32)
+    (f64.le (f64.add (local.get $$x) (local.get $$z)) (f64.add (local.get $$y) (local.get $$z))))
+
+  (func (export "f64.no_fold_add_ge_monotonicity") (param $$x f64) (param $$y f64) (param $$z f64) (result i32)
+    (f64.ge (f64.add (local.get $$x) (local.get $$z)) (f64.add (local.get $$y) (local.get $$z))))
+)`);
+
+// ./test/core/float_exprs.wast:2103
+assert_return(
+  () => invoke($82, `f32.no_fold_add_le_monotonicity`, [
+    value("f32", 0),
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2104
+assert_return(
+  () => invoke($82, `f32.no_fold_add_le_monotonicity`, [
+    value("f32", Infinity),
+    value("f32", -Infinity),
+    value("f32", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2105
+assert_return(
+  () => invoke($82, `f64.no_fold_add_le_monotonicity`, [
+    value("f64", 0),
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2106
+assert_return(
+  () => invoke($82, `f64.no_fold_add_le_monotonicity`, [
+    value("f64", Infinity),
+    value("f64", -Infinity),
+    value("f64", Infinity),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2110
+let $83 = instantiate(`(module
+  (func (export "f32.not_lt") (param $$x f32) (param $$y f32) (result i32)
+    (i32.eqz (f32.lt (local.get $$x) (local.get $$y))))
+
+  (func (export "f32.not_le") (param $$x f32) (param $$y f32) (result i32)
+    (i32.eqz (f32.le (local.get $$x) (local.get $$y))))
+
+  (func (export "f32.not_gt") (param $$x f32) (param $$y f32) (result i32)
+    (i32.eqz (f32.gt (local.get $$x) (local.get $$y))))
+
+  (func (export "f32.not_ge") (param $$x f32) (param $$y f32) (result i32)
+    (i32.eqz (f32.ge (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.not_lt") (param $$x f64) (param $$y f64) (result i32)
+    (i32.eqz (f64.lt (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.not_le") (param $$x f64) (param $$y f64) (result i32)
+    (i32.eqz (f64.le (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.not_gt") (param $$x f64) (param $$y f64) (result i32)
+    (i32.eqz (f64.gt (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.not_ge") (param $$x f64) (param $$y f64) (result i32)
+    (i32.eqz (f64.ge (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:2136
+assert_return(
+  () => invoke($83, `f32.not_lt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2137
+assert_return(
+  () => invoke($83, `f32.not_le`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2138
+assert_return(
+  () => invoke($83, `f32.not_gt`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2139
+assert_return(
+  () => invoke($83, `f32.not_ge`, [
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    value("f32", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2140
+assert_return(
+  () => invoke($83, `f64.not_lt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2141
+assert_return(
+  () => invoke($83, `f64.not_le`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2142
+assert_return(
+  () => invoke($83, `f64.not_gt`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2143
+assert_return(
+  () => invoke($83, `f64.not_ge`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    value("f64", 0),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/float_exprs.wast:2149
+let $84 = instantiate(`(module
+  (func (export "f32.epsilon") (result f32)
+    (f32.sub (f32.const 1.0) (f32.mul (f32.const 3.0) (f32.sub (f32.div (f32.const 4.0) (f32.const 3.0)) (f32.const 1.0)))))
+
+  (func (export "f64.epsilon") (result f64)
+    (f64.sub (f64.const 1.0) (f64.mul (f64.const 3.0) (f64.sub (f64.div (f64.const 4.0) (f64.const 3.0)) (f64.const 1.0)))))
+)`);
+
+// ./test/core/float_exprs.wast:2157
+assert_return(() => invoke($84, `f32.epsilon`, []), [value("f32", -0.00000011920929)]);
+
+// ./test/core/float_exprs.wast:2158
+assert_return(() => invoke($84, `f64.epsilon`, []), [value("f64", 0.0000000000000002220446049250313)]);
+
+// ./test/core/float_exprs.wast:2164
+let $85 = instantiate(`(module
+  (func (export "f32.epsilon") (result f32)
+    (local $$x f32)
+    (local $$result f32)
+    (local.set $$x (f32.const 1))
+    (loop $$loop
+      (br_if $$loop
+        (f32.gt
+          (f32.add
+            (local.tee $$x
+              (f32.mul
+                (local.tee $$result (local.get $$x))
+                (f32.const 0.5)
+              )
+            )
+            (f32.const 1)
+          )
+          (f32.const 1)
+        )
+      )
+    )
+    (local.get $$result)
+  )
+
+  (func (export "f64.epsilon") (result f64)
+    (local $$x f64)
+    (local $$result f64)
+    (local.set $$x (f64.const 1))
+    (loop $$loop
+      (br_if $$loop
+        (f64.gt
+          (f64.add
+            (local.tee $$x
+              (f64.mul
+                (local.tee $$result (local.get $$x))
+                (f64.const 0.5)
+              )
+            )
+            (f64.const 1)
+          )
+          (f64.const 1)
+        )
+      )
+    )
+    (local.get $$result)
+  )
+)`);
+
+// ./test/core/float_exprs.wast:2212
+assert_return(() => invoke($85, `f32.epsilon`, []), [value("f32", 0.00000011920929)]);
+
+// ./test/core/float_exprs.wast:2213
+assert_return(() => invoke($85, `f64.epsilon`, []), [value("f64", 0.0000000000000002220446049250313)]);
+
+// ./test/core/float_exprs.wast:2218
+let $86 = instantiate(`(module
+  (func (export "f32.no_trichotomy_lt") (param $$x f32) (param $$y f32) (result i32)
+    (i32.or (f32.lt (local.get $$x) (local.get $$y)) (f32.ge (local.get $$x) (local.get $$y))))
+  (func (export "f32.no_trichotomy_le") (param $$x f32) (param $$y f32) (result i32)
+    (i32.or (f32.le (local.get $$x) (local.get $$y)) (f32.gt (local.get $$x) (local.get $$y))))
+  (func (export "f32.no_trichotomy_gt") (param $$x f32) (param $$y f32) (result i32)
+    (i32.or (f32.gt (local.get $$x) (local.get $$y)) (f32.le (local.get $$x) (local.get $$y))))
+  (func (export "f32.no_trichotomy_ge") (param $$x f32) (param $$y f32) (result i32)
+    (i32.or (f32.ge (local.get $$x) (local.get $$y)) (f32.lt (local.get $$x) (local.get $$y))))
+
+  (func (export "f64.no_trichotomy_lt") (param $$x f64) (param $$y f64) (result i32)
+    (i32.or (f64.lt (local.get $$x) (local.get $$y)) (f64.ge (local.get $$x) (local.get $$y))))
+  (func (export "f64.no_trichotomy_le") (param $$x f64) (param $$y f64) (result i32)
+    (i32.or (f64.le (local.get $$x) (local.get $$y)) (f64.gt (local.get $$x) (local.get $$y))))
+  (func (export "f64.no_trichotomy_gt") (param $$x f64) (param $$y f64) (result i32)
+    (i32.or (f64.gt (local.get $$x) (local.get $$y)) (f64.le (local.get $$x) (local.get $$y))))
+  (func (export "f64.no_trichotomy_ge") (param $$x f64) (param $$y f64) (result i32)
+    (i32.or (f64.ge (local.get $$x) (local.get $$y)) (f64.lt (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/float_exprs.wast:2238
+assert_return(
+  () => invoke($86, `f32.no_trichotomy_lt`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2239
+assert_return(
+  () => invoke($86, `f32.no_trichotomy_le`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2240
+assert_return(
+  () => invoke($86, `f32.no_trichotomy_gt`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2241
+assert_return(
+  () => invoke($86, `f32.no_trichotomy_ge`, [
+    value("f32", 0),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2242
+assert_return(
+  () => invoke($86, `f64.no_trichotomy_lt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2243
+assert_return(
+  () => invoke($86, `f64.no_trichotomy_le`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2244
+assert_return(
+  () => invoke($86, `f64.no_trichotomy_gt`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2245
+assert_return(
+  () => invoke($86, `f64.no_trichotomy_ge`, [
+    value("f64", 0),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2250
+let $87 = instantiate(`(module
+  (func (export "f32.arithmetic_nan_bitpattern")
+        (param $$x i32) (param $$y i32) (result i32)
+    (i32.and (i32.reinterpret_f32
+               (f32.div
+                 (f32.reinterpret_i32 (local.get $$x))
+                 (f32.reinterpret_i32 (local.get $$y))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.canonical_nan_bitpattern")
+        (param $$x i32) (param $$y i32) (result i32)
+    (i32.and (i32.reinterpret_f32
+               (f32.div
+                 (f32.reinterpret_i32 (local.get $$x))
+                 (f32.reinterpret_i32 (local.get $$y))))
+             (i32.const 0x7fffffff)))
+  (func (export "f32.nonarithmetic_nan_bitpattern")
+        (param $$x i32) (result i32)
+    (i32.reinterpret_f32 (f32.neg (f32.reinterpret_i32 (local.get $$x)))))
+
+  (func (export "f64.arithmetic_nan_bitpattern")
+        (param $$x i64) (param $$y i64) (result i64)
+    (i64.and (i64.reinterpret_f64
+               (f64.div
+                 (f64.reinterpret_i64 (local.get $$x))
+                 (f64.reinterpret_i64 (local.get $$y))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.canonical_nan_bitpattern")
+        (param $$x i64) (param $$y i64) (result i64)
+    (i64.and (i64.reinterpret_f64
+               (f64.div
+                 (f64.reinterpret_i64 (local.get $$x))
+                 (f64.reinterpret_i64 (local.get $$y))))
+             (i64.const 0x7fffffffffffffff)))
+  (func (export "f64.nonarithmetic_nan_bitpattern")
+        (param $$x i64) (result i64)
+    (i64.reinterpret_f64 (f64.neg (f64.reinterpret_i64 (local.get $$x)))))
+
+  ;; Versions of no_fold testcases that only care about NaN bitpatterns.
+  (func (export "f32.no_fold_sub_zero") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get $$x)) (f32.const 0.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_neg0_sub") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.const -0.0) (f32.reinterpret_i32 (local.get $$x))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_mul_one") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get $$x)) (f32.const 1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_neg1_mul") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.const -1.0) (f32.reinterpret_i32 (local.get $$x))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_div_one") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $$x)) (f32.const 1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_div_neg1") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $$x)) (f32.const -1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f64.no_fold_sub_zero") (param $$x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get $$x)) (f64.const 0.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_neg0_sub") (param $$x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.const -0.0) (f64.reinterpret_i64 (local.get $$x))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_mul_one") (param $$x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get $$x)) (f64.const 1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_neg1_mul") (param $$x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.const -1.0) (f64.reinterpret_i64 (local.get $$x))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_div_one") (param $$x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $$x)) (f64.const 1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_div_neg1") (param $$x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $$x)) (f64.const -1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "no_fold_promote_demote") (param $$x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.demote_f64 (f64.promote_f32 (f32.reinterpret_i32 (local.get $$x)))))
+             (i32.const 0x7fc00000)))
+)`);
+
+// ./test/core/float_exprs.wast:2329
+assert_return(
+  () => invoke($87, `f32.arithmetic_nan_bitpattern`, [2139107856, 2139107856]),
+  [value("i32", 2143289344)],
+);
+
+// ./test/core/float_exprs.wast:2330
+assert_return(() => invoke($87, `f32.canonical_nan_bitpattern`, [0, 0]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2331
+assert_return(
+  () => invoke($87, `f32.canonical_nan_bitpattern`, [2143289344, 2143289344]),
+  [value("i32", 2143289344)],
+);
+
+// ./test/core/float_exprs.wast:2332
+assert_return(
+  () => invoke($87, `f32.canonical_nan_bitpattern`, [-4194304, 2143289344]),
+  [value("i32", 2143289344)],
+);
+
+// ./test/core/float_exprs.wast:2333
+assert_return(
+  () => invoke($87, `f32.canonical_nan_bitpattern`, [2143289344, -4194304]),
+  [value("i32", 2143289344)],
+);
+
+// ./test/core/float_exprs.wast:2334
+assert_return(
+  () => invoke($87, `f32.canonical_nan_bitpattern`, [-4194304, -4194304]),
+  [value("i32", 2143289344)],
+);
+
+// ./test/core/float_exprs.wast:2335
+assert_return(
+  () => invoke($87, `f32.nonarithmetic_nan_bitpattern`, [2143302160]),
+  [value("i32", -4181488)],
+);
+
+// ./test/core/float_exprs.wast:2336
+assert_return(
+  () => invoke($87, `f32.nonarithmetic_nan_bitpattern`, [-4181488]),
+  [value("i32", 2143302160)],
+);
+
+// ./test/core/float_exprs.wast:2337
+assert_return(
+  () => invoke($87, `f32.nonarithmetic_nan_bitpattern`, [2139107856]),
+  [value("i32", -8375792)],
+);
+
+// ./test/core/float_exprs.wast:2338
+assert_return(
+  () => invoke($87, `f32.nonarithmetic_nan_bitpattern`, [-8375792]),
+  [value("i32", 2139107856)],
+);
+
+// ./test/core/float_exprs.wast:2339
+assert_return(
+  () => invoke($87, `f64.arithmetic_nan_bitpattern`, [
+    9218868437227418128n,
+    9218868437227418128n,
+  ]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2340
+assert_return(
+  () => invoke($87, `f64.canonical_nan_bitpattern`, [0n, 0n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2341
+assert_return(
+  () => invoke($87, `f64.canonical_nan_bitpattern`, [
+    9221120237041090560n,
+    9221120237041090560n,
+  ]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2342
+assert_return(
+  () => invoke($87, `f64.canonical_nan_bitpattern`, [
+    -2251799813685248n,
+    9221120237041090560n,
+  ]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2343
+assert_return(
+  () => invoke($87, `f64.canonical_nan_bitpattern`, [
+    9221120237041090560n,
+    -2251799813685248n,
+  ]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2344
+assert_return(
+  () => invoke($87, `f64.canonical_nan_bitpattern`, [
+    -2251799813685248n,
+    -2251799813685248n,
+  ]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2345
+assert_return(
+  () => invoke($87, `f64.nonarithmetic_nan_bitpattern`, [9221120237041103376n]),
+  [value("i64", -2251799813672432n)],
+);
+
+// ./test/core/float_exprs.wast:2346
+assert_return(
+  () => invoke($87, `f64.nonarithmetic_nan_bitpattern`, [-2251799813672432n]),
+  [value("i64", 9221120237041103376n)],
+);
+
+// ./test/core/float_exprs.wast:2347
+assert_return(
+  () => invoke($87, `f64.nonarithmetic_nan_bitpattern`, [9218868437227418128n]),
+  [value("i64", -4503599627357680n)],
+);
+
+// ./test/core/float_exprs.wast:2348
+assert_return(
+  () => invoke($87, `f64.nonarithmetic_nan_bitpattern`, [-4503599627357680n]),
+  [value("i64", 9218868437227418128n)],
+);
+
+// ./test/core/float_exprs.wast:2349
+assert_return(() => invoke($87, `f32.no_fold_sub_zero`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2350
+assert_return(() => invoke($87, `f32.no_fold_neg0_sub`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2351
+assert_return(() => invoke($87, `f32.no_fold_mul_one`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2352
+assert_return(() => invoke($87, `f32.no_fold_neg1_mul`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2353
+assert_return(() => invoke($87, `f32.no_fold_div_one`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2354
+assert_return(() => invoke($87, `f32.no_fold_div_neg1`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2355
+assert_return(
+  () => invoke($87, `f64.no_fold_sub_zero`, [9219994337134247936n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2356
+assert_return(
+  () => invoke($87, `f64.no_fold_neg0_sub`, [9219994337134247936n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2357
+assert_return(
+  () => invoke($87, `f64.no_fold_mul_one`, [9219994337134247936n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2358
+assert_return(
+  () => invoke($87, `f64.no_fold_neg1_mul`, [9219994337134247936n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2359
+assert_return(
+  () => invoke($87, `f64.no_fold_div_one`, [9219994337134247936n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2360
+assert_return(
+  () => invoke($87, `f64.no_fold_div_neg1`, [9219994337134247936n]),
+  [value("i64", 9221120237041090560n)],
+);
+
+// ./test/core/float_exprs.wast:2361
+assert_return(() => invoke($87, `no_fold_promote_demote`, [2141192192]), [value("i32", 2143289344)]);
+
+// ./test/core/float_exprs.wast:2366
+let $88 = instantiate(`(module
+  (func (export "dot_product_example")
+        (param $$x0 f64) (param $$x1 f64) (param $$x2 f64) (param $$x3 f64)
+        (param $$y0 f64) (param $$y1 f64) (param $$y2 f64) (param $$y3 f64)
+        (result f64)
+    (f64.add (f64.add (f64.add
+      (f64.mul (local.get $$x0) (local.get $$y0))
+      (f64.mul (local.get $$x1) (local.get $$y1)))
+      (f64.mul (local.get $$x2) (local.get $$y2)))
+      (f64.mul (local.get $$x3) (local.get $$y3)))
+  )
+
+  (func (export "with_binary_sum_collapse")
+        (param $$x0 f64) (param $$x1 f64) (param $$x2 f64) (param $$x3 f64)
+        (param $$y0 f64) (param $$y1 f64) (param $$y2 f64) (param $$y3 f64)
+        (result f64)
+      (f64.add (f64.add (f64.mul (local.get $$x0) (local.get $$y0))
+                        (f64.mul (local.get $$x1) (local.get $$y1)))
+               (f64.add (f64.mul (local.get $$x2) (local.get $$y2))
+                        (f64.mul (local.get $$x3) (local.get $$y3))))
+  )
+)`);
+
+// ./test/core/float_exprs.wast:2389
+assert_return(
+  () => invoke($88, `dot_product_example`, [
+    value("f64", 32000000),
+    value("f64", 1),
+    value("f64", -1),
+    value("f64", 80000000),
+    value("f64", 40000000),
+    value("f64", 1),
+    value("f64", -1),
+    value("f64", -16000000),
+  ]),
+  [value("f64", 2)],
+);
+
+// ./test/core/float_exprs.wast:2393
+assert_return(
+  () => invoke($88, `with_binary_sum_collapse`, [
+    value("f64", 32000000),
+    value("f64", 1),
+    value("f64", -1),
+    value("f64", 80000000),
+    value("f64", 40000000),
+    value("f64", 1),
+    value("f64", -1),
+    value("f64", -16000000),
+  ]),
+  [value("f64", 2)],
+);
+
+// ./test/core/float_exprs.wast:2400
+let $89 = instantiate(`(module
+  (func (export "f32.contract2fma")
+        (param $$x f32) (param $$y f32) (result f32)
+    (f32.sqrt (f32.sub (f32.mul (local.get $$x) (local.get $$x))
+                       (f32.mul (local.get $$y) (local.get $$y)))))
+  (func (export "f64.contract2fma")
+        (param $$x f64) (param $$y f64) (result f64)
+    (f64.sqrt (f64.sub (f64.mul (local.get $$x) (local.get $$x))
+                       (f64.mul (local.get $$y) (local.get $$y)))))
+)`);
+
+// ./test/core/float_exprs.wast:2411
+assert_return(
+  () => invoke($89, `f32.contract2fma`, [value("f32", 1), value("f32", 1)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2412
+assert_return(
+  () => invoke($89, `f32.contract2fma`, [value("f32", 1.1), value("f32", 1.1)]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2413
+assert_return(
+  () => invoke($89, `f32.contract2fma`, [
+    value("f32", 1.1999999),
+    value("f32", 1.1999999),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_exprs.wast:2414
+assert_return(
+  () => invoke($89, `f64.contract2fma`, [value("f64", 1), value("f64", 1)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:2415
+assert_return(
+  () => invoke($89, `f64.contract2fma`, [value("f64", 1.1), value("f64", 1.1)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:2416
+assert_return(
+  () => invoke($89, `f64.contract2fma`, [value("f64", 1.2), value("f64", 1.2)]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_exprs.wast:2421
+let $90 = instantiate(`(module
+  (func (export "f32.division_by_small_number")
+        (param $$a f32) (param $$b f32) (param $$c f32) (result f32)
+    (f32.sub (local.get $$a) (f32.div (local.get $$b) (local.get $$c))))
+  (func (export "f64.division_by_small_number")
+        (param $$a f64) (param $$b f64) (param $$c f64) (result f64)
+    (f64.sub (local.get $$a) (f64.div (local.get $$b) (local.get $$c))))
+)`);
+
+// ./test/core/float_exprs.wast:2430
+assert_return(
+  () => invoke($90, `f32.division_by_small_number`, [
+    value("f32", 112000000),
+    value("f32", 100000),
+    value("f32", 0.0009),
+  ]),
+  [value("f32", 888888)],
+);
+
+// ./test/core/float_exprs.wast:2431
+assert_return(
+  () => invoke($90, `f64.division_by_small_number`, [
+    value("f64", 112000000),
+    value("f64", 100000),
+    value("f64", 0.0009),
+  ]),
+  [value("f64", 888888.8888888806)],
+);
+
+// ./test/core/float_exprs.wast:2436
+let $91 = instantiate(`(module
+  (func (export "f32.golden_ratio") (param $$a f32) (param $$b f32) (param $$c f32) (result f32)
+    (f32.mul (local.get 0) (f32.add (local.get 1) (f32.sqrt (local.get 2)))))
+  (func (export "f64.golden_ratio") (param $$a f64) (param $$b f64) (param $$c f64) (result f64)
+    (f64.mul (local.get 0) (f64.add (local.get 1) (f64.sqrt (local.get 2)))))
+)`);
+
+// ./test/core/float_exprs.wast:2443
+assert_return(
+  () => invoke($91, `f32.golden_ratio`, [
+    value("f32", 0.5),
+    value("f32", 1),
+    value("f32", 5),
+  ]),
+  [value("f32", 1.618034)],
+);
+
+// ./test/core/float_exprs.wast:2444
+assert_return(
+  () => invoke($91, `f64.golden_ratio`, [
+    value("f64", 0.5),
+    value("f64", 1),
+    value("f64", 5),
+  ]),
+  [value("f64", 1.618033988749895)],
+);
+
+// ./test/core/float_exprs.wast:2449
+let $92 = instantiate(`(module
+  (func (export "f32.silver_means") (param $$n f32) (result f32)
+    (f32.mul (f32.const 0.5)
+             (f32.add (local.get $$n)
+                      (f32.sqrt (f32.add (f32.mul (local.get $$n) (local.get $$n))
+                                         (f32.const 4.0))))))
+  (func (export "f64.silver_means") (param $$n f64) (result f64)
+    (f64.mul (f64.const 0.5)
+             (f64.add (local.get $$n)
+                      (f64.sqrt (f64.add (f64.mul (local.get $$n) (local.get $$n))
+                                         (f64.const 4.0))))))
+)`);
+
+// ./test/core/float_exprs.wast:2462
+assert_return(() => invoke($92, `f32.silver_means`, [value("f32", 0)]), [value("f32", 1)]);
+
+// ./test/core/float_exprs.wast:2463
+assert_return(() => invoke($92, `f32.silver_means`, [value("f32", 1)]), [value("f32", 1.618034)]);
+
+// ./test/core/float_exprs.wast:2464
+assert_return(() => invoke($92, `f32.silver_means`, [value("f32", 2)]), [value("f32", 2.4142137)]);
+
+// ./test/core/float_exprs.wast:2465
+assert_return(() => invoke($92, `f32.silver_means`, [value("f32", 3)]), [value("f32", 3.3027756)]);
+
+// ./test/core/float_exprs.wast:2466
+assert_return(() => invoke($92, `f32.silver_means`, [value("f32", 4)]), [value("f32", 4.236068)]);
+
+// ./test/core/float_exprs.wast:2467
+assert_return(() => invoke($92, `f32.silver_means`, [value("f32", 5)]), [value("f32", 5.192582)]);
+
+// ./test/core/float_exprs.wast:2468
+assert_return(() => invoke($92, `f64.silver_means`, [value("f64", 0)]), [value("f64", 1)]);
+
+// ./test/core/float_exprs.wast:2469
+assert_return(
+  () => invoke($92, `f64.silver_means`, [value("f64", 1)]),
+  [value("f64", 1.618033988749895)],
+);
+
+// ./test/core/float_exprs.wast:2470
+assert_return(
+  () => invoke($92, `f64.silver_means`, [value("f64", 2)]),
+  [value("f64", 2.414213562373095)],
+);
+
+// ./test/core/float_exprs.wast:2471
+assert_return(
+  () => invoke($92, `f64.silver_means`, [value("f64", 3)]),
+  [value("f64", 3.302775637731995)],
+);
+
+// ./test/core/float_exprs.wast:2472
+assert_return(
+  () => invoke($92, `f64.silver_means`, [value("f64", 4)]),
+  [value("f64", 4.23606797749979)],
+);
+
+// ./test/core/float_exprs.wast:2473
+assert_return(
+  () => invoke($92, `f64.silver_means`, [value("f64", 5)]),
+  [value("f64", 5.192582403567252)],
+);
+
+// ./test/core/float_exprs.wast:2478
+let $93 = instantiate(`(module
+  (func (export "point_four") (param $$four f64) (param $$ten f64) (result i32)
+    (f64.lt (f64.div (local.get $$four) (local.get $$ten)) (f64.const 0.4)))
+)`);
+
+// ./test/core/float_exprs.wast:2483
+assert_return(() => invoke($93, `point_four`, [value("f64", 4), value("f64", 10)]), [value("i32", 0)]);
+
+// ./test/core/float_exprs.wast:2488
+let $94 = instantiate(`(module
+  (func (export "tau") (param i32) (result f64)
+    (local f64 f64 f64 f64)
+    f64.const 0x0p+0
+    local.set 1
+    block
+      local.get 0
+      i32.const 1
+      i32.lt_s
+      br_if 0
+      f64.const 0x1p+0
+      local.set 2
+      f64.const 0x0p+0
+      local.set 3
+      loop
+        local.get 1
+        local.get 2
+        f64.const 0x1p+3
+        local.get 3
+        f64.const 0x1p+3
+        f64.mul
+        local.tee 4
+        f64.const 0x1p+0
+        f64.add
+        f64.div
+        f64.const 0x1p+2
+        local.get 4
+        f64.const 0x1p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.const 0x1p+1
+        local.get 4
+        f64.const 0x1.4p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.const 0x1p+1
+        local.get 4
+        f64.const 0x1.8p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.mul
+        f64.add
+        local.set 1
+        local.get 3
+        f64.const 0x1p+0
+        f64.add
+        local.set 3
+        local.get 2
+        f64.const 0x1p-4
+        f64.mul
+        local.set 2
+        local.get 0
+        i32.const -1
+        i32.add
+        local.tee 0
+        br_if 0
+      end
+    end
+    local.get 1
+  )
+)`);
+
+// ./test/core/float_exprs.wast:2553
+assert_return(() => invoke($94, `tau`, [10]), [value("f64", 6.283185307179583)]);
+
+// ./test/core/float_exprs.wast:2554
+assert_return(() => invoke($94, `tau`, [11]), [value("f64", 6.283185307179586)]);
+
+// ./test/core/float_exprs.wast:2558
+let $95 = instantiate(`(module
+  (func (export "f32.no_fold_conditional_inc") (param $$x f32) (param $$y f32) (result f32)
+    (select (local.get $$x)
+            (f32.add (local.get $$x) (f32.const 1.0))
+            (f32.lt (local.get $$y) (f32.const 0.0))))
+  (func (export "f64.no_fold_conditional_inc") (param $$x f64) (param $$y f64) (result f64)
+    (select (local.get $$x)
+            (f64.add (local.get $$x) (f64.const 1.0))
+            (f64.lt (local.get $$y) (f64.const 0.0))))
+)`);
+
+// ./test/core/float_exprs.wast:2569
+assert_return(
+  () => invoke($95, `f32.no_fold_conditional_inc`, [value("f32", -0), value("f32", -1)]),
+  [value("f32", -0)],
+);
+
+// ./test/core/float_exprs.wast:2570
+assert_return(
+  () => invoke($95, `f64.no_fold_conditional_inc`, [value("f64", -0), value("f64", -1)]),
+  [value("f64", -0)],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/float_literals.wast.js b/js/src/jit-test/tests/wasm/spec/spec/float_literals.wast.js
new file mode 100644
index 0000000000..c4067bf4f1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/float_literals.wast.js
@@ -0,0 +1,764 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/float_literals.wast
+
+// ./test/core/float_literals.wast:3
+let $0 = instantiate(`(module
+  ;; f32 special values
+  (func (export "f32.nan") (result i32) (i32.reinterpret_f32 (f32.const nan)))
+  (func (export "f32.positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan)))
+  (func (export "f32.negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan)))
+  (func (export "f32.plain_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x400000)))
+  (func (export "f32.informally_known_as_plain_snan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x200000)))
+  (func (export "f32.all_ones_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x7fffff)))
+  (func (export "f32.misc_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x012345)))
+  (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan:0x304050)))
+  (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x2abcde)))
+  (func (export "f32.infinity") (result i32) (i32.reinterpret_f32 (f32.const inf)))
+  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret_f32 (f32.const +inf)))
+  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret_f32 (f32.const -inf)))
+
+  ;; f32 numbers
+  (func (export "f32.zero") (result i32) (i32.reinterpret_f32 (f32.const 0x0.0p0)))
+  (func (export "f32.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0x0.0p0)))
+  (func (export "f32.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0x0.0p0)))
+  (func (export "f32.misc") (result i32) (i32.reinterpret_f32 (f32.const 0x1.921fb6p+2)))
+  (func (export "f32.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-149)))
+  (func (export "f32.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-126)))
+  (func (export "f32.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffep+127)))
+  (func (export "f32.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffcp-127)))
+  (func (export "f32.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 0x1.p10)))
+
+  ;; f32 in decimal format
+  (func (export "f32_dec.zero") (result i32) (i32.reinterpret_f32 (f32.const 0.0e0)))
+  (func (export "f32_dec.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0.0e0)))
+  (func (export "f32_dec.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0.0e0)))
+  (func (export "f32_dec.misc") (result i32) (i32.reinterpret_f32 (f32.const 6.28318548202514648)))
+  (func (export "f32_dec.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 1.4013e-45)))
+  (func (export "f32_dec.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754944e-38)))
+  (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754942e-38)))
+  (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 3.4028234e+38)))
+  (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 1.e10)))
+
+  ;; https://twitter.com/Archivd/status/994637336506912768
+  (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret_f32 (f32.const 1.000000119)))
+
+  ;; f64 special values
+  (func (export "f64.nan") (result i64) (i64.reinterpret_f64 (f64.const nan)))
+  (func (export "f64.positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan)))
+  (func (export "f64.negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan)))
+  (func (export "f64.plain_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x8000000000000)))
+  (func (export "f64.informally_known_as_plain_snan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x4000000000000)))
+  (func (export "f64.all_ones_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0xfffffffffffff)))
+  (func (export "f64.misc_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x0123456789abc)))
+  (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan:0x3040506070809)))
+  (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0x2abcdef012345)))
+  (func (export "f64.infinity") (result i64) (i64.reinterpret_f64 (f64.const inf)))
+  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret_f64 (f64.const +inf)))
+  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret_f64 (f64.const -inf)))
+
+  ;; f64 numbers
+  (func (export "f64.zero") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0p0)))
+  (func (export "f64.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0x0.0p0)))
+  (func (export "f64.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0x0.0p0)))
+  (func (export "f64.misc") (result i64) (i64.reinterpret_f64 (f64.const 0x1.921fb54442d18p+2)))
+  (func (export "f64.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0000000000001p-1022)))
+  (func (export "f64.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 0x1p-1022)))
+  (func (export "f64.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 0x0.fffffffffffffp-1022)))
+  (func (export "f64.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 0x1.fffffffffffffp+1023)))
+  (func (export "f64.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 0x1.p100)))
+
+  ;; f64 numbers in decimal format
+  (func (export "f64_dec.zero") (result i64) (i64.reinterpret_f64 (f64.const 0.0e0)))
+  (func (export "f64_dec.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0.0e0)))
+  (func (export "f64_dec.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0.0e0)))
+  (func (export "f64_dec.misc") (result i64) (i64.reinterpret_f64 (f64.const 6.28318530717958623)))
+  (func (export "f64_dec.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 4.94066e-324)))
+  (func (export "f64_dec.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072012e-308)))
+  (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072011e-308)))
+  (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 1.7976931348623157e+308)))
+  (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 1.e100)))
+
+  ;; https://twitter.com/Archivd/status/994637336506912768
+  (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret_f64 (f64.const 1.000000119)))
+
+  (func (export "f32-dec-sep1") (result f32) (f32.const 1_000_000))
+  (func (export "f32-dec-sep2") (result f32) (f32.const 1_0_0_0))
+  (func (export "f32-dec-sep3") (result f32) (f32.const 100_3.141_592))
+  (func (export "f32-dec-sep4") (result f32) (f32.const 99e+1_3))
+  (func (export "f32-dec-sep5") (result f32) (f32.const 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result f32) (f32.const 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result f32) (f32.const 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result f32) (f32.const 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result f32) (f32.const 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result f32) (f32.const 0x2a_f00a.1f_3_eep2_3))
+
+  (func (export "f64-dec-sep1") (result f64) (f64.const 1_000_000))
+  (func (export "f64-dec-sep2") (result f64) (f64.const 1_0_0_0))
+  (func (export "f64-dec-sep3") (result f64) (f64.const 100_3.141_592))
+  (func (export "f64-dec-sep4") (result f64) (f64.const 99e-1_23))
+  (func (export "f64-dec-sep5") (result f64) (f64.const 122_000.11_3_54e0_2_3))
+  (func (export "f64-hex-sep1") (result f64) (f64.const 0xa_f00f_0000_9999))
+  (func (export "f64-hex-sep2") (result f64) (f64.const 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result f64) (f64.const 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result f64) (f64.const 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result f64) (f64.const 0x2a_f00a.1f_3_eep2_3))
+)`);
+
+// ./test/core/float_literals.wast:105
+assert_return(() => invoke($0, `f32.nan`, []), [value("i32", 2143289344)]);
+
+// ./test/core/float_literals.wast:106
+assert_return(() => invoke($0, `f32.positive_nan`, []), [value("i32", 2143289344)]);
+
+// ./test/core/float_literals.wast:107
+assert_return(() => invoke($0, `f32.negative_nan`, []), [value("i32", -4194304)]);
+
+// ./test/core/float_literals.wast:108
+assert_return(() => invoke($0, `f32.plain_nan`, []), [value("i32", 2143289344)]);
+
+// ./test/core/float_literals.wast:109
+assert_return(() => invoke($0, `f32.informally_known_as_plain_snan`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_literals.wast:110
+assert_return(() => invoke($0, `f32.all_ones_nan`, []), [value("i32", -1)]);
+
+// ./test/core/float_literals.wast:111
+assert_return(() => invoke($0, `f32.misc_nan`, []), [value("i32", 2139169605)]);
+
+// ./test/core/float_literals.wast:112
+assert_return(() => invoke($0, `f32.misc_positive_nan`, []), [value("i32", 2142257232)]);
+
+// ./test/core/float_literals.wast:113
+assert_return(() => invoke($0, `f32.misc_negative_nan`, []), [value("i32", -5587746)]);
+
+// ./test/core/float_literals.wast:114
+assert_return(() => invoke($0, `f32.infinity`, []), [value("i32", 2139095040)]);
+
+// ./test/core/float_literals.wast:115
+assert_return(() => invoke($0, `f32.positive_infinity`, []), [value("i32", 2139095040)]);
+
+// ./test/core/float_literals.wast:116
+assert_return(() => invoke($0, `f32.negative_infinity`, []), [value("i32", -8388608)]);
+
+// ./test/core/float_literals.wast:117
+assert_return(() => invoke($0, `f32.zero`, []), [value("i32", 0)]);
+
+// ./test/core/float_literals.wast:118
+assert_return(() => invoke($0, `f32.positive_zero`, []), [value("i32", 0)]);
+
+// ./test/core/float_literals.wast:119
+assert_return(() => invoke($0, `f32.negative_zero`, []), [value("i32", -2147483648)]);
+
+// ./test/core/float_literals.wast:120
+assert_return(() => invoke($0, `f32.misc`, []), [value("i32", 1086918619)]);
+
+// ./test/core/float_literals.wast:121
+assert_return(() => invoke($0, `f32.min_positive`, []), [value("i32", 1)]);
+
+// ./test/core/float_literals.wast:122
+assert_return(() => invoke($0, `f32.min_normal`, []), [value("i32", 8388608)]);
+
+// ./test/core/float_literals.wast:123
+assert_return(() => invoke($0, `f32.max_subnormal`, []), [value("i32", 8388607)]);
+
+// ./test/core/float_literals.wast:124
+assert_return(() => invoke($0, `f32.max_finite`, []), [value("i32", 2139095039)]);
+
+// ./test/core/float_literals.wast:125
+assert_return(() => invoke($0, `f32.trailing_dot`, []), [value("i32", 1149239296)]);
+
+// ./test/core/float_literals.wast:126
+assert_return(() => invoke($0, `f32_dec.zero`, []), [value("i32", 0)]);
+
+// ./test/core/float_literals.wast:127
+assert_return(() => invoke($0, `f32_dec.positive_zero`, []), [value("i32", 0)]);
+
+// ./test/core/float_literals.wast:128
+assert_return(() => invoke($0, `f32_dec.negative_zero`, []), [value("i32", -2147483648)]);
+
+// ./test/core/float_literals.wast:129
+assert_return(() => invoke($0, `f32_dec.misc`, []), [value("i32", 1086918619)]);
+
+// ./test/core/float_literals.wast:130
+assert_return(() => invoke($0, `f32_dec.min_positive`, []), [value("i32", 1)]);
+
+// ./test/core/float_literals.wast:131
+assert_return(() => invoke($0, `f32_dec.min_normal`, []), [value("i32", 8388608)]);
+
+// ./test/core/float_literals.wast:132
+assert_return(() => invoke($0, `f32_dec.max_subnormal`, []), [value("i32", 8388607)]);
+
+// ./test/core/float_literals.wast:133
+assert_return(() => invoke($0, `f32_dec.max_finite`, []), [value("i32", 2139095039)]);
+
+// ./test/core/float_literals.wast:134
+assert_return(() => invoke($0, `f32_dec.trailing_dot`, []), [value("i32", 1343554297)]);
+
+// ./test/core/float_literals.wast:135
+assert_return(() => invoke($0, `f32_dec.root_beer_float`, []), [value("i32", 1065353217)]);
+
+// ./test/core/float_literals.wast:137
+assert_return(() => invoke($0, `f64.nan`, []), [value("i64", 9221120237041090560n)]);
+
+// ./test/core/float_literals.wast:138
+assert_return(() => invoke($0, `f64.positive_nan`, []), [value("i64", 9221120237041090560n)]);
+
+// ./test/core/float_literals.wast:139
+assert_return(() => invoke($0, `f64.negative_nan`, []), [value("i64", -2251799813685248n)]);
+
+// ./test/core/float_literals.wast:140
+assert_return(() => invoke($0, `f64.plain_nan`, []), [value("i64", 9221120237041090560n)]);
+
+// ./test/core/float_literals.wast:141
+assert_return(
+  () => invoke($0, `f64.informally_known_as_plain_snan`, []),
+  [value("i64", 9219994337134247936n)],
+);
+
+// ./test/core/float_literals.wast:142
+assert_return(() => invoke($0, `f64.all_ones_nan`, []), [value("i64", -1n)]);
+
+// ./test/core/float_literals.wast:143
+assert_return(() => invoke($0, `f64.misc_nan`, []), [value("i64", 9218888453225749180n)]);
+
+// ./test/core/float_literals.wast:144
+assert_return(() => invoke($0, `f64.misc_positive_nan`, []), [value("i64", 9219717281780008969n)]);
+
+// ./test/core/float_literals.wast:145
+assert_return(() => invoke($0, `f64.misc_negative_nan`, []), [value("i64", -3751748707474619n)]);
+
+// ./test/core/float_literals.wast:146
+assert_return(() => invoke($0, `f64.infinity`, []), [value("i64", 9218868437227405312n)]);
+
+// ./test/core/float_literals.wast:147
+assert_return(() => invoke($0, `f64.positive_infinity`, []), [value("i64", 9218868437227405312n)]);
+
+// ./test/core/float_literals.wast:148
+assert_return(() => invoke($0, `f64.negative_infinity`, []), [value("i64", -4503599627370496n)]);
+
+// ./test/core/float_literals.wast:149
+assert_return(() => invoke($0, `f64.zero`, []), [value("i64", 0n)]);
+
+// ./test/core/float_literals.wast:150
+assert_return(() => invoke($0, `f64.positive_zero`, []), [value("i64", 0n)]);
+
+// ./test/core/float_literals.wast:151
+assert_return(() => invoke($0, `f64.negative_zero`, []), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/float_literals.wast:152
+assert_return(() => invoke($0, `f64.misc`, []), [value("i64", 4618760256179416344n)]);
+
+// ./test/core/float_literals.wast:153
+assert_return(() => invoke($0, `f64.min_positive`, []), [value("i64", 1n)]);
+
+// ./test/core/float_literals.wast:154
+assert_return(() => invoke($0, `f64.min_normal`, []), [value("i64", 4503599627370496n)]);
+
+// ./test/core/float_literals.wast:155
+assert_return(() => invoke($0, `f64.max_subnormal`, []), [value("i64", 4503599627370495n)]);
+
+// ./test/core/float_literals.wast:156
+assert_return(() => invoke($0, `f64.max_finite`, []), [value("i64", 9218868437227405311n)]);
+
+// ./test/core/float_literals.wast:157
+assert_return(() => invoke($0, `f64.trailing_dot`, []), [value("i64", 5057542381537067008n)]);
+
+// ./test/core/float_literals.wast:158
+assert_return(() => invoke($0, `f64_dec.zero`, []), [value("i64", 0n)]);
+
+// ./test/core/float_literals.wast:159
+assert_return(() => invoke($0, `f64_dec.positive_zero`, []), [value("i64", 0n)]);
+
+// ./test/core/float_literals.wast:160
+assert_return(() => invoke($0, `f64_dec.negative_zero`, []), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/float_literals.wast:161
+assert_return(() => invoke($0, `f64_dec.misc`, []), [value("i64", 4618760256179416344n)]);
+
+// ./test/core/float_literals.wast:162
+assert_return(() => invoke($0, `f64_dec.min_positive`, []), [value("i64", 1n)]);
+
+// ./test/core/float_literals.wast:163
+assert_return(() => invoke($0, `f64_dec.min_normal`, []), [value("i64", 4503599627370496n)]);
+
+// ./test/core/float_literals.wast:164
+assert_return(() => invoke($0, `f64_dec.max_subnormal`, []), [value("i64", 4503599627370495n)]);
+
+// ./test/core/float_literals.wast:165
+assert_return(() => invoke($0, `f64_dec.max_finite`, []), [value("i64", 9218868437227405311n)]);
+
+// ./test/core/float_literals.wast:166
+assert_return(() => invoke($0, `f64_dec.trailing_dot`, []), [value("i64", 6103021453049119613n)]);
+
+// ./test/core/float_literals.wast:167
+assert_return(() => invoke($0, `f64_dec.root_beer_float`, []), [value("i64", 4607182419335945764n)]);
+
+// ./test/core/float_literals.wast:169
+assert_return(() => invoke($0, `f32-dec-sep1`, []), [value("f32", 1000000)]);
+
+// ./test/core/float_literals.wast:170
+assert_return(() => invoke($0, `f32-dec-sep2`, []), [value("f32", 1000)]);
+
+// ./test/core/float_literals.wast:171
+assert_return(() => invoke($0, `f32-dec-sep3`, []), [value("f32", 1003.1416)]);
+
+// ./test/core/float_literals.wast:172
+assert_return(() => invoke($0, `f32-dec-sep4`, []), [value("f32", 990000000000000)]);
+
+// ./test/core/float_literals.wast:173
+assert_return(() => invoke($0, `f32-dec-sep5`, []), [value("f32", 12200012000000000000000000000)]);
+
+// ./test/core/float_literals.wast:174
+assert_return(() => invoke($0, `f32-hex-sep1`, []), [value("f32", 168755360)]);
+
+// ./test/core/float_literals.wast:175
+assert_return(() => invoke($0, `f32-hex-sep2`, []), [value("f32", 109071)]);
+
+// ./test/core/float_literals.wast:176
+assert_return(() => invoke($0, `f32-hex-sep3`, []), [value("f32", 41215.94)]);
+
+// ./test/core/float_literals.wast:177
+assert_return(() => invoke($0, `f32-hex-sep4`, []), [value("f32", 1966080)]);
+
+// ./test/core/float_literals.wast:178
+assert_return(() => invoke($0, `f32-hex-sep5`, []), [value("f32", 23605224000000)]);
+
+// ./test/core/float_literals.wast:180
+assert_return(() => invoke($0, `f64-dec-sep1`, []), [value("f64", 1000000)]);
+
+// ./test/core/float_literals.wast:181
+assert_return(() => invoke($0, `f64-dec-sep2`, []), [value("f64", 1000)]);
+
+// ./test/core/float_literals.wast:182
+assert_return(() => invoke($0, `f64-dec-sep3`, []), [value("f64", 1003.141592)]);
+
+// ./test/core/float_literals.wast:183
+assert_return(
+  () => invoke($0, `f64-dec-sep4`, []),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000099),
+  ],
+);
+
+// ./test/core/float_literals.wast:184
+assert_return(() => invoke($0, `f64-dec-sep5`, []), [value("f64", 12200011354000000000000000000)]);
+
+// ./test/core/float_literals.wast:185
+assert_return(() => invoke($0, `f64-hex-sep1`, []), [value("f64", 3078696982321561)]);
+
+// ./test/core/float_literals.wast:186
+assert_return(() => invoke($0, `f64-hex-sep2`, []), [value("f64", 109071)]);
+
+// ./test/core/float_literals.wast:187
+assert_return(() => invoke($0, `f64-hex-sep3`, []), [value("f64", 41215.94240794191)]);
+
+// ./test/core/float_literals.wast:188
+assert_return(() => invoke($0, `f64-hex-sep4`, []), [value("f64", 1966080)]);
+
+// ./test/core/float_literals.wast:189
+assert_return(() => invoke($0, `f64-hex-sep5`, []), [value("f64", 23605225168752)]);
+
+// ./test/core/float_literals.wast:192
+let $1 = instantiate(`(module binary
+  ;; (func (export "4294967249") (result f64) (f64.const 4294967249))
+  "\\00\\61\\73\\6d\\01\\00\\00\\00\\01\\85\\80\\80\\80\\00\\01\\60"
+  "\\00\\01\\7c\\03\\82\\80\\80\\80\\00\\01\\00\\07\\8e\\80\\80\\80"
+  "\\00\\01\\0a\\34\\32\\39\\34\\39\\36\\37\\32\\34\\39\\00\\00\\0a"
+  "\\91\\80\\80\\80\\00\\01\\8b\\80\\80\\80\\00\\00\\44\\00\\00\\20"
+  "\\fa\\ff\\ff\\ef\\41\\0b"
+)`);
+
+// ./test/core/float_literals.wast:201
+assert_return(() => invoke($1, `4294967249`, []), [value("f64", 4294967249)]);
+
+// ./test/core/float_literals.wast:203
+assert_malformed(() => instantiate(`(global f32 (f32.const _100)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:207
+assert_malformed(() => instantiate(`(global f32 (f32.const +_100)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:211
+assert_malformed(() => instantiate(`(global f32 (f32.const -_100)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:215
+assert_malformed(() => instantiate(`(global f32 (f32.const 99_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:219
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:223
+assert_malformed(() => instantiate(`(global f32 (f32.const _1.0)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:227
+assert_malformed(() => instantiate(`(global f32 (f32.const 1.0_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:231
+assert_malformed(() => instantiate(`(global f32 (f32.const 1_.0)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:235
+assert_malformed(() => instantiate(`(global f32 (f32.const 1._0)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:239
+assert_malformed(() => instantiate(`(global f32 (f32.const _1e1)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:243
+assert_malformed(() => instantiate(`(global f32 (f32.const 1e1_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:247
+assert_malformed(() => instantiate(`(global f32 (f32.const 1_e1)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:251
+assert_malformed(() => instantiate(`(global f32 (f32.const 1e_1)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:255
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const _1.0e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:259
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 1.0e1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:263
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 1.0_e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:267
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 1.0e_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:271
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 1.0e+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:275
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 1.0e_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:279
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:283
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:287
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:291
+assert_malformed(() => instantiate(`(global f32 (f32.const 0x00_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:295
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0xff__ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:299
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x_1.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:303
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1.0_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:307
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1_.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:311
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1._0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:315
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x_1p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:319
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:323
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:327
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:331
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x_1.0p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:335
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1.0p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:339
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1.0_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:343
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1.0p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:347
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1.0p+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:351
+assert_malformed(
+  () => instantiate(`(global f32 (f32.const 0x1.0p_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:356
+assert_malformed(() => instantiate(`(global f64 (f64.const _100)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:360
+assert_malformed(() => instantiate(`(global f64 (f64.const +_100)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:364
+assert_malformed(() => instantiate(`(global f64 (f64.const -_100)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:368
+assert_malformed(() => instantiate(`(global f64 (f64.const 99_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:372
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:376
+assert_malformed(() => instantiate(`(global f64 (f64.const _1.0)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:380
+assert_malformed(() => instantiate(`(global f64 (f64.const 1.0_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:384
+assert_malformed(() => instantiate(`(global f64 (f64.const 1_.0)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:388
+assert_malformed(() => instantiate(`(global f64 (f64.const 1._0)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:392
+assert_malformed(() => instantiate(`(global f64 (f64.const _1e1)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:396
+assert_malformed(() => instantiate(`(global f64 (f64.const 1e1_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:400
+assert_malformed(() => instantiate(`(global f64 (f64.const 1_e1)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:404
+assert_malformed(() => instantiate(`(global f64 (f64.const 1e_1)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:408
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const _1.0e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:412
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 1.0e1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:416
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 1.0_e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:420
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 1.0e_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:424
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 1.0e+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:428
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 1.0e_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:432
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:436
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:440
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:444
+assert_malformed(() => instantiate(`(global f64 (f64.const 0x00_)) `), `unknown operator`);
+
+// ./test/core/float_literals.wast:448
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0xff__ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:452
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x_1.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:456
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1.0_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:460
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1_.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:464
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1._0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:468
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x_1p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:472
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:476
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:480
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:484
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x_1.0p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:488
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1.0p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:492
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1.0_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:496
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1.0p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:500
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1.0p+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/float_literals.wast:504
+assert_malformed(
+  () => instantiate(`(global f64 (f64.const 0x1.0p_+1)) `),
+  `unknown operator`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/float_memory.wast.js b/js/src/jit-test/tests/wasm/spec/spec/float_memory.wast.js
new file mode 100644
index 0000000000..8f01f424e8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/float_memory.wast.js
@@ -0,0 +1,361 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/float_memory.wast
+
+// ./test/core/float_memory.wast:5
+let $0 = instantiate(`(module
+  (memory (data "\\00\\00\\a0\\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 0)))
+  (func (export "i32.load") (result i32) (i32.load (i32.const 0)))
+  (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x200000)))
+  (func (export "i32.store") (i32.store (i32.const 0) (i32.const 0x7fa00000)))
+  (func (export "reset") (i32.store (i32.const 0) (i32.const 0)))
+)`);
+
+// ./test/core/float_memory.wast:15
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory.wast:16
+assert_return(() => invoke($0, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory.wast:17
+invoke($0, `reset`, []);
+
+// ./test/core/float_memory.wast:18
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory.wast:19
+assert_return(() => invoke($0, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory.wast:20
+invoke($0, `f32.store`, []);
+
+// ./test/core/float_memory.wast:21
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory.wast:22
+assert_return(() => invoke($0, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory.wast:23
+invoke($0, `reset`, []);
+
+// ./test/core/float_memory.wast:24
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory.wast:25
+assert_return(() => invoke($0, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory.wast:26
+invoke($0, `i32.store`, []);
+
+// ./test/core/float_memory.wast:27
+assert_return(() => invoke($0, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory.wast:28
+assert_return(() => invoke($0, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory.wast:30
+let $1 = instantiate(`(module
+  (memory (data "\\00\\00\\00\\00\\00\\00\\f4\\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 0)))
+  (func (export "i64.load") (result i64) (i64.load (i32.const 0)))
+  (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0x4000000000000)))
+  (func (export "i64.store") (i64.store (i32.const 0) (i64.const 0x7ff4000000000000)))
+  (func (export "reset") (i64.store (i32.const 0) (i64.const 0)))
+)`);
+
+// ./test/core/float_memory.wast:40
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory.wast:41
+assert_return(
+  () => invoke($1, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:42
+invoke($1, `reset`, []);
+
+// ./test/core/float_memory.wast:43
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory.wast:44
+assert_return(() => invoke($1, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory.wast:45
+invoke($1, `f64.store`, []);
+
+// ./test/core/float_memory.wast:46
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory.wast:47
+assert_return(
+  () => invoke($1, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:48
+invoke($1, `reset`, []);
+
+// ./test/core/float_memory.wast:49
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory.wast:50
+assert_return(() => invoke($1, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory.wast:51
+invoke($1, `i64.store`, []);
+
+// ./test/core/float_memory.wast:52
+assert_return(() => invoke($1, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory.wast:53
+assert_return(
+  () => invoke($1, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:57
+let $2 = instantiate(`(module
+  (memory (data "\\00\\00\\00\\a0\\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 1)))
+  (func (export "i32.load") (result i32) (i32.load (i32.const 1)))
+  (func (export "f32.store") (f32.store (i32.const 1) (f32.const nan:0x200000)))
+  (func (export "i32.store") (i32.store (i32.const 1) (i32.const 0x7fa00000)))
+  (func (export "reset") (i32.store (i32.const 1) (i32.const 0)))
+)`);
+
+// ./test/core/float_memory.wast:67
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory.wast:68
+assert_return(() => invoke($2, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory.wast:69
+invoke($2, `reset`, []);
+
+// ./test/core/float_memory.wast:70
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory.wast:71
+assert_return(() => invoke($2, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory.wast:72
+invoke($2, `f32.store`, []);
+
+// ./test/core/float_memory.wast:73
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory.wast:74
+assert_return(() => invoke($2, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory.wast:75
+invoke($2, `reset`, []);
+
+// ./test/core/float_memory.wast:76
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory.wast:77
+assert_return(() => invoke($2, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory.wast:78
+invoke($2, `i32.store`, []);
+
+// ./test/core/float_memory.wast:79
+assert_return(() => invoke($2, `i32.load`, []), [value("i32", 2141192192)]);
+
+// ./test/core/float_memory.wast:80
+assert_return(() => invoke($2, `f32.load`, []), [bytes("f32", [0x0, 0x0, 0xa0, 0x7f])]);
+
+// ./test/core/float_memory.wast:82
+let $3 = instantiate(`(module
+  (memory (data "\\00\\00\\00\\00\\00\\00\\00\\f4\\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 1)))
+  (func (export "i64.load") (result i64) (i64.load (i32.const 1)))
+  (func (export "f64.store") (f64.store (i32.const 1) (f64.const nan:0x4000000000000)))
+  (func (export "i64.store") (i64.store (i32.const 1) (i64.const 0x7ff4000000000000)))
+  (func (export "reset") (i64.store (i32.const 1) (i64.const 0)))
+)`);
+
+// ./test/core/float_memory.wast:92
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory.wast:93
+assert_return(
+  () => invoke($3, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:94
+invoke($3, `reset`, []);
+
+// ./test/core/float_memory.wast:95
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory.wast:96
+assert_return(() => invoke($3, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory.wast:97
+invoke($3, `f64.store`, []);
+
+// ./test/core/float_memory.wast:98
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory.wast:99
+assert_return(
+  () => invoke($3, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:100
+invoke($3, `reset`, []);
+
+// ./test/core/float_memory.wast:101
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory.wast:102
+assert_return(() => invoke($3, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory.wast:103
+invoke($3, `i64.store`, []);
+
+// ./test/core/float_memory.wast:104
+assert_return(() => invoke($3, `i64.load`, []), [value("i64", 9219994337134247936n)]);
+
+// ./test/core/float_memory.wast:105
+assert_return(
+  () => invoke($3, `f64.load`, []),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:109
+let $4 = instantiate(`(module
+  (memory (data "\\01\\00\\d0\\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 0)))
+  (func (export "i32.load") (result i32) (i32.load (i32.const 0)))
+  (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x500001)))
+  (func (export "i32.store") (i32.store (i32.const 0) (i32.const 0x7fd00001)))
+  (func (export "reset") (i32.store (i32.const 0) (i32.const 0)))
+)`);
+
+// ./test/core/float_memory.wast:119
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 2144337921)]);
+
+// ./test/core/float_memory.wast:120
+assert_return(() => invoke($4, `f32.load`, []), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/float_memory.wast:121
+invoke($4, `reset`, []);
+
+// ./test/core/float_memory.wast:122
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory.wast:123
+assert_return(() => invoke($4, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory.wast:124
+invoke($4, `f32.store`, []);
+
+// ./test/core/float_memory.wast:125
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 2144337921)]);
+
+// ./test/core/float_memory.wast:126
+assert_return(() => invoke($4, `f32.load`, []), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/float_memory.wast:127
+invoke($4, `reset`, []);
+
+// ./test/core/float_memory.wast:128
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 0)]);
+
+// ./test/core/float_memory.wast:129
+assert_return(() => invoke($4, `f32.load`, []), [value("f32", 0)]);
+
+// ./test/core/float_memory.wast:130
+invoke($4, `i32.store`, []);
+
+// ./test/core/float_memory.wast:131
+assert_return(() => invoke($4, `i32.load`, []), [value("i32", 2144337921)]);
+
+// ./test/core/float_memory.wast:132
+assert_return(() => invoke($4, `f32.load`, []), [bytes("f32", [0x1, 0x0, 0xd0, 0x7f])]);
+
+// ./test/core/float_memory.wast:134
+let $5 = instantiate(`(module
+  (memory (data "\\01\\00\\00\\00\\00\\00\\fc\\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 0)))
+  (func (export "i64.load") (result i64) (i64.load (i32.const 0)))
+  (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0xc000000000001)))
+  (func (export "i64.store") (i64.store (i32.const 0) (i64.const 0x7ffc000000000001)))
+  (func (export "reset") (i64.store (i32.const 0) (i64.const 0)))
+)`);
+
+// ./test/core/float_memory.wast:144
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 9222246136947933185n)]);
+
+// ./test/core/float_memory.wast:145
+assert_return(
+  () => invoke($5, `f64.load`, []),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:146
+invoke($5, `reset`, []);
+
+// ./test/core/float_memory.wast:147
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory.wast:148
+assert_return(() => invoke($5, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory.wast:149
+invoke($5, `f64.store`, []);
+
+// ./test/core/float_memory.wast:150
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 9222246136947933185n)]);
+
+// ./test/core/float_memory.wast:151
+assert_return(
+  () => invoke($5, `f64.load`, []),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
+
+// ./test/core/float_memory.wast:152
+invoke($5, `reset`, []);
+
+// ./test/core/float_memory.wast:153
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 0n)]);
+
+// ./test/core/float_memory.wast:154
+assert_return(() => invoke($5, `f64.load`, []), [value("f64", 0)]);
+
+// ./test/core/float_memory.wast:155
+invoke($5, `i64.store`, []);
+
+// ./test/core/float_memory.wast:156
+assert_return(() => invoke($5, `i64.load`, []), [value("i64", 9222246136947933185n)]);
+
+// ./test/core/float_memory.wast:157
+assert_return(
+  () => invoke($5, `f64.load`, []),
+  [bytes("f64", [0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0xfc, 0x7f])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/float_misc.wast.js b/js/src/jit-test/tests/wasm/spec/spec/float_misc.wast.js
new file mode 100644
index 0000000000..9d7598b363
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/float_misc.wast.js
@@ -0,0 +1,3679 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/float_misc.wast
+
+// ./test/core/float_misc.wast:17
+let $0 = instantiate(`(module
+  (func (export "f32.add") (param $$x f32) (param $$y f32) (result f32) (f32.add (local.get $$x) (local.get $$y)))
+  (func (export "f32.sub") (param $$x f32) (param $$y f32) (result f32) (f32.sub (local.get $$x) (local.get $$y)))
+  (func (export "f32.mul") (param $$x f32) (param $$y f32) (result f32) (f32.mul (local.get $$x) (local.get $$y)))
+  (func (export "f32.div") (param $$x f32) (param $$y f32) (result f32) (f32.div (local.get $$x) (local.get $$y)))
+  (func (export "f32.sqrt") (param $$x f32) (result f32) (f32.sqrt (local.get $$x)))
+  (func (export "f32.abs") (param $$x f32) (result f32) (f32.abs (local.get $$x)))
+  (func (export "f32.neg") (param $$x f32) (result f32) (f32.neg (local.get $$x)))
+  (func (export "f32.copysign") (param $$x f32) (param $$y f32) (result f32) (f32.copysign (local.get $$x) (local.get $$y)))
+  (func (export "f32.ceil") (param $$x f32) (result f32) (f32.ceil (local.get $$x)))
+  (func (export "f32.floor") (param $$x f32) (result f32) (f32.floor (local.get $$x)))
+  (func (export "f32.trunc") (param $$x f32) (result f32) (f32.trunc (local.get $$x)))
+  (func (export "f32.nearest") (param $$x f32) (result f32) (f32.nearest (local.get $$x)))
+  (func (export "f32.min") (param $$x f32) (param $$y f32) (result f32) (f32.min (local.get $$x) (local.get $$y)))
+  (func (export "f32.max") (param $$x f32) (param $$y f32) (result f32) (f32.max (local.get $$x) (local.get $$y)))
+
+  (func (export "f64.add") (param $$x f64) (param $$y f64) (result f64) (f64.add (local.get $$x) (local.get $$y)))
+  (func (export "f64.sub") (param $$x f64) (param $$y f64) (result f64) (f64.sub (local.get $$x) (local.get $$y)))
+  (func (export "f64.mul") (param $$x f64) (param $$y f64) (result f64) (f64.mul (local.get $$x) (local.get $$y)))
+  (func (export "f64.div") (param $$x f64) (param $$y f64) (result f64) (f64.div (local.get $$x) (local.get $$y)))
+  (func (export "f64.sqrt") (param $$x f64) (result f64) (f64.sqrt (local.get $$x)))
+  (func (export "f64.abs") (param $$x f64) (result f64) (f64.abs (local.get $$x)))
+  (func (export "f64.neg") (param $$x f64) (result f64) (f64.neg (local.get $$x)))
+  (func (export "f64.copysign") (param $$x f64) (param $$y f64) (result f64) (f64.copysign (local.get $$x) (local.get $$y)))
+  (func (export "f64.ceil") (param $$x f64) (result f64) (f64.ceil (local.get $$x)))
+  (func (export "f64.floor") (param $$x f64) (result f64) (f64.floor (local.get $$x)))
+  (func (export "f64.trunc") (param $$x f64) (result f64) (f64.trunc (local.get $$x)))
+  (func (export "f64.nearest") (param $$x f64) (result f64) (f64.nearest (local.get $$x)))
+  (func (export "f64.min") (param $$x f64) (param $$y f64) (result f64) (f64.min (local.get $$x) (local.get $$y)))
+  (func (export "f64.max") (param $$x f64) (param $$y f64) (result f64) (f64.max (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/float_misc.wast:50
+assert_return(
+  () => invoke($0, `f32.add`, [value("f32", 1.1234568), value("f32", 0.00000000012345)]),
+  [value("f32", 1.1234568)],
+);
+
+// ./test/core/float_misc.wast:51
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 1.123456789),
+    value("f64", 0.00000000012345),
+  ]),
+  [value("f64", 1.12345678912345)],
+);
+
+// ./test/core/float_misc.wast:55
+assert_return(
+  () => invoke($0, `f32.add`, [value("f32", 1), value("f32", 0.000000059604645)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_misc.wast:56
+assert_return(
+  () => invoke($0, `f32.add`, [value("f32", 1), value("f32", 0.00000005960465)]),
+  [value("f32", 1.0000001)],
+);
+
+// ./test/core/float_misc.wast:57
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 1),
+    value("f64", 0.00000000000000011102230246251565),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_misc.wast:58
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 1),
+    value("f64", 0.00000000000000011102230246251568),
+  ]),
+  [value("f64", 1.0000000000000002)],
+);
+
+// ./test/core/float_misc.wast:61
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.000000000000000000000000000000000000000000001),
+    value("f32", 0.000000000000000000000000000000000000011754942),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/float_misc.wast:62
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/float_misc.wast:67
+assert_return(
+  () => invoke($0, `f32.add`, [value("f32", 2147483600), value("f32", 1024.25)]),
+  [value("f32", 2147484700)],
+);
+
+// ./test/core/float_misc.wast:68
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 9223372036854776000),
+    value("f64", 1024.25),
+  ]),
+  [value("f64", 9223372036854778000)],
+);
+
+// ./test/core/float_misc.wast:72
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645561009778199),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000292),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036455610097781983),
+  ],
+);
+
+// ./test/core/float_misc.wast:75
+assert_return(
+  () => invoke($0, `f64.add`, [value("f64", 9007199254740992), value("f64", 1.00001)]),
+  [value("f64", 9007199254740994)],
+);
+
+// ./test/core/float_misc.wast:78
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 9007199254740994),
+    value("f64", 0.9999847412109375),
+  ]),
+  [value("f64", 9007199254740994)],
+);
+
+// ./test/core/float_misc.wast:81
+assert_return(
+  () => invoke($0, `f32.add`, [value("f32", 8388608), value("f32", 0.5)]),
+  [value("f32", 8388608)],
+);
+
+// ./test/core/float_misc.wast:82
+assert_return(
+  () => invoke($0, `f32.add`, [value("f32", 8388609), value("f32", 0.5)]),
+  [value("f32", 8388610)],
+);
+
+// ./test/core/float_misc.wast:83
+assert_return(
+  () => invoke($0, `f64.add`, [value("f64", 4503599627370496), value("f64", 0.5)]),
+  [value("f64", 4503599627370496)],
+);
+
+// ./test/core/float_misc.wast:84
+assert_return(
+  () => invoke($0, `f64.add`, [value("f64", 4503599627370497), value("f64", 0.5)]),
+  [value("f64", 4503599627370498)],
+);
+
+// ./test/core/float_misc.wast:87
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -6207600000000000000000000000000),
+    value("f32", 0.000000000000000000000000000002309799),
+  ]),
+  [value("f32", -6207600000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:88
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 209865800000000000000),
+    value("f32", -5270152500000000),
+  ]),
+  [value("f32", 209860530000000000000)],
+);
+
+// ./test/core/float_misc.wast:89
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.0000000000000000000000001963492),
+    value("f32", 0.000000000000000000000000000000000000046220067),
+  ]),
+  [value("f32", 0.0000000000000000000000001963492)],
+);
+
+// ./test/core/float_misc.wast:90
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 640905000000),
+    value("f32", -64449550000000000),
+  ]),
+  [value("f32", -64448910000000000)],
+);
+
+// ./test/core/float_misc.wast:91
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.0000601966),
+    value("f32", 120372790000000000000000000000000),
+  ]),
+  [value("f32", 120372790000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:92
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009218993827002741),
+    value("f64", -1283078243878048500000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -1283078243878048500000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:93
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -96503407870148960000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000004670208988478548),
+  ]),
+  [value("f64", -96503407870148960000000)],
+);
+
+// ./test/core/float_misc.wast:94
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.0000000000000000000000000000000000000000000028559147675434106),
+    value("f64", -0.00026124280570653086),
+  ]),
+  [value("f64", -0.00026124280570653086)],
+);
+
+// ./test/core/float_misc.wast:95
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 79335564741512700000),
+  ]),
+  [
+    value("f64", 417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:96
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 8265442868747023000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:99
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 5238404000000000000000),
+    value("f32", -1570182.5),
+  ]),
+  [value("f32", 5238404000000000000000)],
+);
+
+// ./test/core/float_misc.wast:100
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.00000000000004258938),
+    value("f32", -0.0000000000000000000000057092353),
+  ]),
+  [value("f32", 0.00000000000004258938)],
+);
+
+// ./test/core/float_misc.wast:101
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.00000000000027251026),
+    value("f32", 83711560000000000000000000000000000000),
+  ]),
+  [value("f32", 83711560000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:102
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.0000000000000884536),
+    value("f32", -0.000000000000000000000000000000015165626),
+  ]),
+  [value("f32", -0.0000000000000884536)],
+);
+
+// ./test/core/float_misc.wast:103
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.0010521035),
+    value("f32", -0.000000000000000000000000000000007582135),
+  ]),
+  [value("f32", 0.0010521035)],
+);
+
+// ./test/core/float_misc.wast:104
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 1511135228188924600000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169),
+  ]),
+  [value("f64", 1511135228188924600000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:105
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 62386719760360280000000000000000000000000000000),
+    value("f64", -0.0000000000000000008592185488839212),
+  ]),
+  [value("f64", 62386719760360280000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:106
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029225342022551453),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354),
+  ],
+);
+
+// ./test/core/float_misc.wast:107
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -215220546714824520000000000000000000000000000),
+    value("f64", -1112220412047137200000000000000000000000000),
+  ]),
+  [value("f64", -216332767126871650000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:108
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -13.6911535055856),
+    value("f64", 2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:111
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.000000000000000000000000000000000006456021),
+    value("f32", 0.00000000000020219949),
+  ]),
+  [value("f32", 0.00000000000020219949)],
+);
+
+// ./test/core/float_misc.wast:112
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.000026823169),
+    value("f32", 0.000000011196016),
+  ]),
+  [value("f32", -0.000026811973)],
+);
+
+// ./test/core/float_misc.wast:113
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -128526170000),
+    value("f32", 0.0000000000000000000000000000000027356305),
+  ]),
+  [value("f32", -128526170000)],
+);
+
+// ./test/core/float_misc.wast:114
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.000000000000000000000000000000000004158973),
+    value("f32", -1573528700),
+  ]),
+  [value("f32", -1573528700)],
+);
+
+// ./test/core/float_misc.wast:115
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.0000000000000000000000000000000000009338769),
+    value("f32", 78647514000000000000000000000),
+  ]),
+  [value("f32", 78647514000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:116
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021986596650683218),
+    value("f64", -235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:117
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -314175619593595700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -30114098514611660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -314175649707694230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:118
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013722858367681836),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977),
+  ],
+);
+
+// ./test/core/float_misc.wast:119
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016862581574752944),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075),
+  ],
+);
+
+// ./test/core/float_misc.wast:120
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 8374007930974482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:123
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -210896605327889950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 581483233421196300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 581483022524591100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:124
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 102315792666821480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 450204300797494900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 102315792667271680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:125
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -130529978570956560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 154899434220186570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 154899434220186450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:126
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 47629997434721684000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:127
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003958952516558414),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023092460710062946),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000230924607140219),
+  ],
+);
+
+// ./test/core/float_misc.wast:130
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -43780558475415996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:131
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 21174311168546080000000000000000000000000000000000000000000),
+    value("f64", -26385928474612128000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -26385928474612128000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:132
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007858068235728165),
+  ]),
+  [
+    value("f64", -9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:133
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005079144928553737),
+    value("f64", -354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:134
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000004165382103988111),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000004165382103988111),
+  ],
+);
+
+// ./test/core/float_misc.wast:137
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 97215650000000000000000000000000000),
+    value("f32", 305590870000000000000000000000000000000),
+  ]),
+  [value("f32", 305688080000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:138
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 270465630000000000000000000000000000000),
+    value("f32", -230236850000000000000000000000000),
+  ]),
+  [value("f32", 270465400000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:139
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 357209300000000000000000000000000000),
+    value("f32", -236494050000000000000000000000000000000),
+  ]),
+  [value("f32", -236136840000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:140
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -1484234100000000000000000000000000000),
+    value("f32", -328991400000000000000000000000000000000),
+  ]),
+  [value("f32", -330475620000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:141
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -219885600000000000000000000000000000000),
+    value("f32", -81560930000000000000000000000000000000),
+  ]),
+  [value("f32", -301446520000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:142
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 90390204939547630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 22943337422040356000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 90390204939570580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:143
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 165916059736246050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 12577349331444160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 165916059748823400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:144
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -136351292561394300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 60507030603873580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -136290785530790440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:145
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -34377613258227424000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 169947152758793490000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 169947118381180220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:146
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 92273427008645570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -39269416451018680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 92273426969376150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:149
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.000000000000000000000000000000000000008313455),
+    value("f32", 0.000000000000000000000000000000000000000000873),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000008314328)],
+);
+
+// ./test/core/float_misc.wast:150
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.000000000000000000000000000000000000000000052),
+    value("f32", -0.000000000000000000000000000000000000000000003),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000049)],
+);
+
+// ./test/core/float_misc.wast:151
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.000000000000000000000000000000000000000000011),
+    value("f32", 0.000000000000000000000000000000000000005186284),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000005186273)],
+);
+
+// ./test/core/float_misc.wast:152
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", -0.000000000000000000000000000000000000000000028),
+    value("f32", 0.00000000000000000000000000000000000023675283),
+  ]),
+  [value("f32", 0.0000000000000000000000000000000000002367528)],
+);
+
+// ./test/core/float_misc.wast:153
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 0.000000000000000000000000000000000000000000635),
+    value("f32", -0.00000000000000000000000000000000000000003327),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000000032635)],
+);
+
+// ./test/core/float_misc.wast:154
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028461489375936755),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005130160608603642),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002284011671009967),
+  ],
+);
+
+// ./test/core/float_misc.wast:155
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047404811354775),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008895417776504167),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004154936641026667),
+  ],
+);
+
+// ./test/core/float_misc.wast:156
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009330082001250494),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029863980609419717),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003919406261067021),
+  ],
+);
+
+// ./test/core/float_misc.wast:157
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014418693884494008),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016324914377759187),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906220493265178),
+  ],
+);
+
+// ./test/core/float_misc.wast:158
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043203619362281506),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002521511966399844),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017988499698283067),
+  ],
+);
+
+// ./test/core/float_misc.wast:162
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 340282330000000000000000000000000000000),
+    value("f32", 20282410000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:163
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 19958403095347200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:166
+assert_return(() => invoke($0, `f32.add`, [value("f32", 2), value("f32", 2)]), [value("f32", 4)]);
+
+// ./test/core/float_misc.wast:167
+assert_return(() => invoke($0, `f64.add`, [value("f64", 2), value("f64", 2)]), [value("f64", 4)]);
+
+// ./test/core/float_misc.wast:170
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 10141204000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:171
+assert_return(
+  () => invoke($0, `f32.add`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 10141205000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:172
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:173
+assert_return(
+  () => invoke($0, `f64.add`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_misc.wast:177
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 65536), value("f32", 0.000000000007275958)]),
+  [value("f32", 65536)],
+);
+
+// ./test/core/float_misc.wast:178
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 65536),
+    value("f64", 0.000000000007275957614183426),
+  ]),
+  [value("f64", 65535.99999999999)],
+);
+
+// ./test/core/float_misc.wast:182
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1), value("f32", 0.000000029802322)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_misc.wast:183
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1), value("f32", 0.000000029802326)]),
+  [value("f32", 0.99999994)],
+);
+
+// ./test/core/float_misc.wast:184
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 1),
+    value("f64", 0.00000000000000005551115123125783),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_misc.wast:185
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 1),
+    value("f64", 0.00000000000000005551115123125784),
+  ]),
+  [value("f64", 0.9999999999999999)],
+);
+
+// ./test/core/float_misc.wast:188
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 0.00000000000000000000000000000002379208),
+    value("f32", -722129800000000000000000000000000000),
+  ]),
+  [value("f32", 722129800000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:189
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -842284000000000000000000000000000000),
+    value("f32", -11118414000000),
+  ]),
+  [value("f32", -842284000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:190
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 1.4549444),
+    value("f32", -0.00000000000000000000000033792615),
+  ]),
+  [value("f32", 1.4549444)],
+);
+
+// ./test/core/float_misc.wast:191
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 0.0000000000000000000000000000000000094808914),
+    value("f32", 0.000000000000000000000018589502),
+  ]),
+  [value("f32", -0.000000000000000000000018589502)],
+);
+
+// ./test/core/float_misc.wast:192
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 0.000006181167),
+    value("f32", -0.0000000000000000000000000000000093959864),
+  ]),
+  [value("f32", 0.000006181167)],
+);
+
+// ./test/core/float_misc.wast:193
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002524845082116609),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413),
+  ],
+);
+
+// ./test/core/float_misc.wast:194
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.0000000000000000000000000000000000000000000000038165079778426864),
+  ]),
+  [
+    value("f64", -20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:195
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020889465194336087),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332),
+  ],
+);
+
+// ./test/core/float_misc.wast:196
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000303879528930943),
+    value("f64", -23204941114021897000000000000000000000000000000),
+  ]),
+  [value("f64", 23204941114021897000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:197
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.00000000000000000000000000000000000000000014953904039036317),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683),
+  ]),
+  [value("f64", -0.00000000000000000000000000000000000000000014953904039036317)],
+);
+
+// ./test/core/float_misc.wast:200
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -448601660000000000000000000000000),
+    value("f32", -8984148000000000000000000000000000),
+  ]),
+  [value("f32", 8535546400000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:201
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -899427400000000000000000000000000),
+    value("f32", 91.579384),
+  ]),
+  [value("f32", -899427400000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:202
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -0.00000000000000000000000011975),
+    value("f32", 0.000000063140405),
+  ]),
+  [value("f32", -0.000000063140405)],
+);
+
+// ./test/core/float_misc.wast:203
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -0.000000000000000000000011800487),
+    value("f32", -0.00031558736),
+  ]),
+  [value("f32", 0.00031558736)],
+);
+
+// ./test/core/float_misc.wast:204
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -736483800000000000000000000000),
+    value("f32", 0.0000000000000000030824513),
+  ]),
+  [value("f32", -736483800000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:205
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -9410469964196796000000000000000000000000000000000000000000000),
+    value("f64", -17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:206
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002339448785991429),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173),
+  ],
+);
+
+// ./test/core/float_misc.wast:207
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000009719219783531962),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000009719219783531962),
+  ],
+);
+
+// ./test/core/float_misc.wast:208
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034908896031751274),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208),
+  ],
+);
+
+// ./test/core/float_misc.wast:209
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -7538298763725556000000000000000000),
+    value("f64", 4447012580193329000000000000000000000000000000000000),
+  ]),
+  [value("f64", -4447012580193329000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:212
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 75846976000000000000000000000),
+    value("f32", 0.000046391753),
+  ]),
+  [value("f32", 75846976000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:213
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -567139.9),
+    value("f32", -0.000000000030334842),
+  ]),
+  [value("f32", -567139.9)],
+);
+
+// ./test/core/float_misc.wast:214
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -0.000000000017412261),
+    value("f32", -0.000000000000000017877793),
+  ]),
+  [value("f32", -0.000000000017412244)],
+);
+
+// ./test/core/float_misc.wast:215
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -0.000065645545),
+    value("f32", 0.00014473806),
+  ]),
+  [value("f32", -0.00021038362)],
+);
+
+// ./test/core/float_misc.wast:216
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", -0.00000000016016115),
+    value("f32", -0.000000000000000000000000000000085380075),
+  ]),
+  [value("f32", -0.00000000016016115)],
+);
+
+// ./test/core/float_misc.wast:217
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000009358725267183177),
+    value("f64", -31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:218
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -4390767596767215000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:219
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036288281010831153),
+    value("f64", 3383199683245004400000000000000000000000000000000000000),
+  ]),
+  [value("f64", -3383199683245004400000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:220
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645097751812619),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423490969686624),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423491006137603),
+  ],
+);
+
+// ./test/core/float_misc.wast:221
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008021529638989887),
+    value("f64", -0.00006774972769072139),
+  ]),
+  [value("f64", 0.00006774972769072139)],
+);
+
+// ./test/core/float_misc.wast:224
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.000000000000000000000005816988065793039),
+    value("f64", 0.000000000000000000000000000000000025021499241540866),
+  ]),
+  [value("f64", 0.000000000000000000000005816988065768018)],
+);
+
+// ./test/core/float_misc.wast:225
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683304809554),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016945582607476316),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683135353726),
+  ],
+);
+
+// ./test/core/float_misc.wast:226
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000006908052676315257),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000012001773734799856),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000012001773734799856),
+  ],
+);
+
+// ./test/core/float_misc.wast:227
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.0000000000022044291547443813),
+    value("f64", -0.0000000000000000000027947429925618632),
+  ]),
+  [value("f64", -0.000000000002204429151949638)],
+);
+
+// ./test/core/float_misc.wast:228
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.00000004016393569117761),
+    value("f64", 0.17053881989395447),
+  ]),
+  [value("f64", -0.17053877973001877)],
+);
+
+// ./test/core/float_misc.wast:231
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010015106898667285),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004785375958943186),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047853759589431757),
+  ],
+);
+
+// ./test/core/float_misc.wast:232
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", -15618959953.641388),
+    value("f64", 598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:233
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 38832071540376680000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304),
+  ]),
+  [value("f64", 38832071540376680000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:234
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017466607734737216),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897),
+  ],
+);
+
+// ./test/core/float_misc.wast:235
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.00000000000000000949378346261834),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294),
+  ]),
+  [value("f64", 0.00000000000000000949378346261834)],
+);
+
+// ./test/core/float_misc.wast:239
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 23.140692), value("f32", 3.1415927)]),
+  [value("f32", 19.9991)],
+);
+
+// ./test/core/float_misc.wast:240
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 23.14069263277927),
+    value("f64", 3.141592653589793),
+  ]),
+  [value("f64", 19.999099979189477)],
+);
+
+// ./test/core/float_misc.wast:243
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 2999999), value("f32", 2999998)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_misc.wast:244
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1999999), value("f32", 1999995)]),
+  [value("f32", 4)],
+);
+
+// ./test/core/float_misc.wast:245
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1999999), value("f32", 1999993)]),
+  [value("f32", 6)],
+);
+
+// ./test/core/float_misc.wast:246
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 400002), value("f32", 400001)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_misc.wast:247
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 400002), value("f32", 400000)]),
+  [value("f32", 2)],
+);
+
+// ./test/core/float_misc.wast:248
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 2999999999999999),
+    value("f64", 2999999999999998),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_misc.wast:249
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 1999999999999999),
+    value("f64", 1999999999999995),
+  ]),
+  [value("f64", 4)],
+);
+
+// ./test/core/float_misc.wast:250
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 1999999999999999),
+    value("f64", 1999999999999993),
+  ]),
+  [value("f64", 6)],
+);
+
+// ./test/core/float_misc.wast:251
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 400000000000002),
+    value("f64", 400000000000001),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_misc.wast:252
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 400000000000002),
+    value("f64", 400000000000000),
+  ]),
+  [value("f64", 2)],
+);
+
+// ./test/core/float_misc.wast:255
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754942),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_misc.wast:256
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/float_misc.wast:259
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1.0000001), value("f32", 0.99999994)]),
+  [value("f32", 0.00000017881393)],
+);
+
+// ./test/core/float_misc.wast:260
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1.0000001), value("f32", 1)]),
+  [value("f32", 0.00000011920929)],
+);
+
+// ./test/core/float_misc.wast:261
+assert_return(
+  () => invoke($0, `f32.sub`, [value("f32", 1), value("f32", 0.99999994)]),
+  [value("f32", 0.000000059604645)],
+);
+
+// ./test/core/float_misc.wast:262
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 1.0000000000000002),
+    value("f64", 0.9999999999999999),
+  ]),
+  [value("f64", 0.00000000000000033306690738754696)],
+);
+
+// ./test/core/float_misc.wast:263
+assert_return(
+  () => invoke($0, `f64.sub`, [value("f64", 1.0000000000000002), value("f64", 1)]),
+  [value("f64", 0.0000000000000002220446049250313)],
+);
+
+// ./test/core/float_misc.wast:264
+assert_return(
+  () => invoke($0, `f64.sub`, [value("f64", 1), value("f64", 0.9999999999999999)]),
+  [value("f64", 0.00000000000000011102230246251565)],
+);
+
+// ./test/core/float_misc.wast:268
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 10141204000000000000000000000000),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:269
+assert_return(
+  () => invoke($0, `f32.sub`, [
+    value("f32", 340282350000000000000000000000000000000),
+    value("f32", 10141205000000000000000000000000),
+  ]),
+  [value("f32", 340282330000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:270
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:271
+assert_return(
+  () => invoke($0, `f64.sub`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:274
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 1000000000000000),
+    value("f32", 1000000000000000),
+  ]),
+  [value("f32", 999999940000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:275
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 100000000000000000000),
+    value("f32", 100000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:276
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 10000000000000000000000000),
+    value("f32", 10000000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:277
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 1000000000000000),
+    value("f64", 1000000000000000),
+  ]),
+  [value("f64", 1000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:278
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 100000000000000000000),
+    value("f64", 100000000000000000000),
+  ]),
+  [value("f64", 10000000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:279
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 10000000000000000000000000),
+    value("f64", 10000000000000000000000000),
+  ]),
+  [value("f64", 100000000000000030000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:284
+assert_return(
+  () => invoke($0, `f32.mul`, [value("f32", 1848874900), value("f32", 19954563000)]),
+  [value("f32", 36893493000000000000)],
+);
+
+// ./test/core/float_misc.wast:285
+assert_return(
+  () => invoke($0, `f64.mul`, [value("f64", 1848874847), value("f64", 19954562207)]),
+  [value("f64", 36893488147419110000)],
+);
+
+// ./test/core/float_misc.wast:289
+assert_return(
+  () => invoke($0, `f32.mul`, [value("f32", 77.1), value("f32", 850)]),
+  [value("f32", 65535)],
+);
+
+// ./test/core/float_misc.wast:290
+assert_return(
+  () => invoke($0, `f64.mul`, [value("f64", 77.1), value("f64", 850)]),
+  [value("f64", 65534.99999999999)],
+);
+
+// ./test/core/float_misc.wast:293
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -2493839400000000000),
+    value("f32", 0.000000000021176054),
+  ]),
+  [value("f32", -52809680)],
+);
+
+// ./test/core/float_misc.wast:294
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -6777248400000000000000000000000),
+    value("f32", -0.00000000000000000000000000000034758242),
+  ]),
+  [value("f32", 2.3556523)],
+);
+
+// ./test/core/float_misc.wast:295
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -8384397600000000000000000000),
+    value("f32", -0.000000000000000000000000000011948991),
+  ]),
+  [value("f32", 0.10018509)],
+);
+
+// ./test/core/float_misc.wast:296
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -656765400000000000000000),
+    value("f32", -0.000000000000000000000046889766),
+  ]),
+  [value("f32", 30.795576)],
+);
+
+// ./test/core/float_misc.wast:297
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 13328204000000000),
+    value("f32", 45.567223),
+  ]),
+  [value("f32", 607329200000000000)],
+);
+
+// ./test/core/float_misc.wast:298
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -99426226093342430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 583177241514245140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_misc.wast:299
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002748155824301909),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000002093035437779455),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_misc.wast:300
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 464888257371302500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -159272886487254360000000000000000),
+  ]),
+  [
+    value("f64", -74044094645556960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:301
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008261927764172427),
+    value("f64", 36684744190529535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -3030867065492991300000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:302
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 253838958331769250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105),
+  ]),
+  [value("f64", 0.00000000000000000019908317594263248)],
+);
+
+// ./test/core/float_misc.wast:305
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -0.0000000000000000000000000020153333),
+    value("f32", -5031353000000000000000000000),
+  ]),
+  [value("f32", 10.139854)],
+);
+
+// ./test/core/float_misc.wast:306
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 12286325000000000000000),
+    value("f32", 749601.8),
+  ]),
+  [value("f32", 9209852000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:307
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -0.0000000002763514),
+    value("f32", -35524714000000000000000),
+  ]),
+  [value("f32", 9817304000000)],
+);
+
+// ./test/core/float_misc.wast:308
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 218931220000000000000),
+    value("f32", -40298.785),
+  ]),
+  [value("f32", -8822662000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:309
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 1691996300),
+    value("f32", -122103350000000000000),
+  ]),
+  [value("f32", -206598410000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:310
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007576316076452304),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004601355879514986),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003486132652344772),
+  ],
+);
+
+// ./test/core/float_misc.wast:311
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012228616081443885),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008055526185180067),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009850793705258527),
+  ],
+);
+
+// ./test/core/float_misc.wast:312
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -2068651246039250800000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -366801071583254800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_misc.wast:313
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 1543238835610281000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007370621385787007),
+  ]),
+  [
+    value("f64", 1137462916512617700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:314
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 2235876566242058700000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -760669005920257000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -1700762005003744000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:317
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -110087030000000),
+    value("f32", -54038020000000000000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:318
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -0.19366351),
+    value("f32", 0.0000000000000000000000000000029748954),
+  ]),
+  [value("f32", -0.0000000000000000000000000000005761287)],
+);
+
+// ./test/core/float_misc.wast:319
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -0.0000034300713),
+    value("f32", 77991523000000000000000000000000),
+  ]),
+  [value("f32", -267516490000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:320
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -99003850000000000),
+    value("f32", 0.000000000000000000000000000020933774),
+  ]),
+  [value("f32", -0.0000000000020725242)],
+);
+
+// ./test/core/float_misc.wast:321
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -129919.07),
+    value("f32", 0.0000000000000000000000000000000000018480999),
+  ]),
+  [value("f32", -0.00000000000000000000000000000024010342)],
+);
+
+// ./test/core/float_misc.wast:322
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006625572200844895),
+    value("f64", -37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.00000000000000000024762427246273877)],
+);
+
+// ./test/core/float_misc.wast:323
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 821076848561758000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012976552328552289),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000010654746691124455),
+  ],
+);
+
+// ./test/core/float_misc.wast:324
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -10223449294906041000000000000000000000000000000000000),
+    value("f64", 1970855583334680500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -20148942123804574000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:325
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 2918243080119086000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -63633170941689700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/float_misc.wast:326
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 3407037798802672000000000),
+    value("f64", 1225791423971563000000),
+  ]),
+  [value("f64", 4176317714919266400000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:329
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044091927284399547),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011518840702296592),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078878866462432),
+  ],
+);
+
+// ./test/core/float_misc.wast:330
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.002980041826472432),
+    value("f64", 63125412993218000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -188116371033135940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:331
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -308344578081300100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010081049555008529),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000031084369716557833),
+  ],
+);
+
+// ./test/core/float_misc.wast:332
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 349387501315677300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 2131316915930809900),
+  ]),
+  [
+    value("f64", 744655491768901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:333
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012500108005100234),
+    value("f64", 1035265704160467500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -12940933115981990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:336
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008947461661755698),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020853844141312436),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018658897095462173),
+  ],
+);
+
+// ./test/core/float_misc.wast:337
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.00000000000000001161813037330394),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018737038135583668),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021768935186877886),
+  ],
+);
+
+// ./test/core/float_misc.wast:338
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021752326768352433),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006631210068072052),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014424424827029184),
+  ],
+);
+
+// ./test/core/float_misc.wast:339
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007149518157441743),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000022770445062365393),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001627977104264113),
+  ],
+);
+
+// ./test/core/float_misc.wast:340
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004817739302150786),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025375023049719763),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012225024583961697),
+  ],
+);
+
+// ./test/core/float_misc.wast:343
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 46576441629501554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714),
+  ]),
+  [value("f64", 0.000000003270292605938992)],
+);
+
+// ./test/core/float_misc.wast:344
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.012451716278313712),
+    value("f64", 0.000000000000000000000000000000000000000000001945309177849331),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000002422243795617958),
+  ],
+);
+
+// ./test/core/float_misc.wast:345
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -3.8312314777598586),
+    value("f64", 0.0000000000009039887741742674),
+  ]),
+  [value("f64", -0.0000000000034633902471580017)],
+);
+
+// ./test/core/float_misc.wast:346
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009843582638849689),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000003375405654777583),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033226084502443684),
+  ],
+);
+
+// ./test/core/float_misc.wast:347
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", -260544537094514460000000),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032887528185809035),
+  ]),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000008568665807354412),
+  ],
+);
+
+// ./test/core/float_misc.wast:350
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 0.00000000000000000000002646978),
+    value("f32", 0.00000000000000000000002646978),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_misc.wast:351
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 0.000000000000000000000026469783),
+    value("f32", 0.000000000000000000000026469783),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_misc.wast:352
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_misc.wast:353
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288),
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/float_misc.wast:356
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 18446743000000000000),
+    value("f32", 18446743000000000000),
+  ]),
+  [value("f32", 340282330000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:357
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 18446744000000000000),
+    value("f32", 18446744000000000000),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:358
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:359
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_misc.wast:362
+assert_return(
+  () => invoke($0, `f32.mul`, [value("f32", 1.0000001), value("f32", 1.0000001)]),
+  [value("f32", 1.0000002)],
+);
+
+// ./test/core/float_misc.wast:363
+assert_return(
+  () => invoke($0, `f32.mul`, [value("f32", 0.99999994), value("f32", 0.99999994)]),
+  [value("f32", 0.9999999)],
+);
+
+// ./test/core/float_misc.wast:364
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 1.0000000000000002),
+    value("f64", 1.0000000000000002),
+  ]),
+  [value("f64", 1.0000000000000004)],
+);
+
+// ./test/core/float_misc.wast:365
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.9999999999999999),
+    value("f64", 0.9999999999999999),
+  ]),
+  [value("f64", 0.9999999999999998)],
+);
+
+// ./test/core/float_misc.wast:368
+assert_return(
+  () => invoke($0, `f32.mul`, [value("f32", 1.0000001), value("f32", 0.99999994)]),
+  [value("f32", 1)],
+);
+
+// ./test/core/float_misc.wast:369
+assert_return(
+  () => invoke($0, `f32.mul`, [value("f32", 1.0000002), value("f32", 0.9999999)]),
+  [value("f32", 1.0000001)],
+);
+
+// ./test/core/float_misc.wast:370
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 1.0000000000000002),
+    value("f64", 0.9999999999999999),
+  ]),
+  [value("f64", 1)],
+);
+
+// ./test/core/float_misc.wast:371
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 1.0000000000000004),
+    value("f64", 0.9999999999999998),
+  ]),
+  [value("f64", 1.0000000000000002)],
+);
+
+// ./test/core/float_misc.wast:375
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.00000011920929),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_misc.wast:376
+assert_return(
+  () => invoke($0, `f64.mul`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.0000000000000002220446049250313),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/float_misc.wast:379
+assert_return(
+  () => invoke($0, `f32.mul`, [
+    value("f32", -16.001465),
+    value("f32", 0.000000000000000000000000000000000000000298465),
+  ]),
+  [value("f32", -0.000000000000000000000000000000000000004775883)],
+);
+
+// ./test/core/float_misc.wast:382
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 1.1234568), value("f32", 100)]),
+  [value("f32", 0.011234568)],
+);
+
+// ./test/core/float_misc.wast:383
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 8391667), value("f32", 12582905)]),
+  [value("f32", 0.6669102)],
+);
+
+// ./test/core/float_misc.wast:384
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 65536), value("f32", 0.000000000007275958)]),
+  [value("f32", 9007199000000000)],
+);
+
+// ./test/core/float_misc.wast:385
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1.8622957),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000005472795)],
+);
+
+// ./test/core/float_misc.wast:386
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 4), value("f32", 3)]),
+  [value("f32", 1.3333334)],
+);
+
+// ./test/core/float_misc.wast:387
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 1.123456789), value("f64", 100)]),
+  [value("f64", 0.01123456789)],
+);
+
+// ./test/core/float_misc.wast:388
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 8391667), value("f64", 12582905)]),
+  [value("f64", 0.6669101451532854)],
+);
+
+// ./test/core/float_misc.wast:389
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 65536),
+    value("f64", 0.000000000007275957614183426),
+  ]),
+  [value("f64", 9007199254740992)],
+);
+
+// ./test/core/float_misc.wast:390
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1.8622957468032837),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001035936395755283),
+  ],
+);
+
+// ./test/core/float_misc.wast:391
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 4), value("f64", 3)]),
+  [value("f64", 1.3333333333333333)],
+);
+
+// ./test/core/float_misc.wast:395
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 4195835), value("f32", 3145727)]),
+  [value("f32", 1.3338205)],
+);
+
+// ./test/core/float_misc.wast:396
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 4195835), value("f64", 3145727)]),
+  [value("f64", 1.333820449136241)],
+);
+
+// ./test/core/float_misc.wast:399
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.000000000000005029633),
+    value("f32", 336324380000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_misc.wast:400
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.000000000000000000000000008921987),
+    value("f32", 354097530000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_misc.wast:401
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -104167.47),
+    value("f32", 0.0000000000000000000000015866623),
+  ]),
+  [value("f32", -65651950000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:402
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -0.000000000000000000000024938657),
+    value("f32", -0.00000000000000000000000000000000000036230088),
+  ]),
+  [value("f32", 68834107000000)],
+);
+
+// ./test/core/float_misc.wast:403
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -4142204200000),
+    value("f32", 0.0000000000000000000000011954948),
+  ]),
+  [value("f32", -3464845000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:404
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 193901163824483840000000000000000000000000000),
+    value("f64", 25290742357348314000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0.000000000000000000000007666883046955921)],
+);
+
+// ./test/core/float_misc.wast:405
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006600332149752304),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003007915153468629),
+  ]),
+  [
+    value("f64", 219432125342399270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:406
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -934827517366190300000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 4809309529035847000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019437873809582001),
+  ],
+);
+
+// ./test/core/float_misc.wast:407
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -17598339088417535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 199386072580682850000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -88262629684409150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:408
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -4566268877844991000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -145968816036246260000000000)],
+);
+
+// ./test/core/float_misc.wast:411
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -1039406400000000000000),
+    value("f32", -0.000000000000000000000000012965966),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:412
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.000000000000026831563),
+    value("f32", 31241038000000),
+  ]),
+  [value("f32", 0.0000000000000000000000000008588563)],
+);
+
+// ./test/core/float_misc.wast:413
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1.2734247),
+    value("f32", -692783700000000000000000000),
+  ]),
+  [value("f32", -0.0000000000000000000000000018381274)],
+);
+
+// ./test/core/float_misc.wast:414
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.00000000000000068988827),
+    value("f32", 0.000000000000000000000000000000000000003762676),
+  ]),
+  [value("f32", 183350460000000000000000)],
+);
+
+// ./test/core/float_misc.wast:415
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1819916200000000000000000000),
+    value("f32", 205067030000000000000000000),
+  ]),
+  [value("f32", 8.874739)],
+);
+
+// ./test/core/float_misc.wast:416
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021137715924428077),
+    value("f64", -16733261612910253000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/float_misc.wast:417
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008116644948016275),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006517571349002277),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012453480772801648),
+  ],
+);
+
+// ./test/core/float_misc.wast:418
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009335476912259029),
+    value("f64", -39099281466396.5),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023876338802497726),
+  ],
+);
+
+// ./test/core/float_misc.wast:419
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -1686856985488590200000000),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013535993861076857),
+  ]),
+  [
+    value("f64", -12462010568276012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:420
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -173388773324941200000000000000000000000000000000000000000000000000000000),
+    value("f64", -70026160475217470),
+  ]),
+  [value("f64", 2476057121342590000000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:423
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 93506190),
+    value("f32", 0.0000000000000000000000000000000000028760885),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:424
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -200575400000000000000000),
+    value("f32", 246697220),
+  ]),
+  [value("f32", -813042800000000)],
+);
+
+// ./test/core/float_misc.wast:425
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 384712200000),
+    value("f32", -107037850000000000000000000000),
+  ]),
+  [value("f32", -0.00000000000000000359417)],
+);
+
+// ./test/core/float_misc.wast:426
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -4156665000000000000000000000000000),
+    value("f32", -901.4192),
+  ]),
+  [value("f32", 4611245300000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:427
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -6702387000000000000000000000),
+    value("f32", -14000.255),
+  ]),
+  [value("f32", 478733200000000000000000)],
+);
+
+// ./test/core/float_misc.wast:428
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010085269598907525),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018780374032850215),
+  ]),
+  [value("f64", -53701111496.85621)],
+);
+
+// ./test/core/float_misc.wast:429
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -32571664562951100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005885738519211168),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_misc.wast:430
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031640946861233317),
+    value("f64", 0.000000000000000000045854510556516254),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006900291046010721),
+  ],
+);
+
+// ./test/core/float_misc.wast:431
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -526842242946656600000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014816907071451201),
+  ]),
+  [
+    value("f64", 355568298030134360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:432
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 4039956270017490000000000000000000000000000000000000000),
+    value("f64", -47097881971884274000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", -0.0000000000857778757955442)],
+);
+
+// ./test/core/float_misc.wast:435
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -203959560468347600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -74740887394612260000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 2728888665604071000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:436
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -304261712294687660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", -2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 114570204320220420000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:437
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 49235240512480730000000000000000000000000000000000000000),
+    value("f64", -366340828310036700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013439736089369927),
+  ],
+);
+
+// ./test/core/float_misc.wast:438
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 289260843556341600000000000000000000000000000000000000000000000000),
+    value("f64", 517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000005592879146144478),
+  ],
+);
+
+// ./test/core/float_misc.wast:439
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -421542582344268600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1428505854670649100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -295093352936560340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:442
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1.8622957433108482),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010359363938125513),
+  ],
+);
+
+// ./test/core/float_misc.wast:443
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008566632480779937),
+    value("f64", 5381.2699796556235),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001591935084685746),
+  ],
+);
+
+// ./test/core/float_misc.wast:444
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.00000000000000000000000000000000000000000008196220919495565),
+    value("f64", -10406557086484777000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007876015911295176),
+  ],
+);
+
+// ./test/core/float_misc.wast:445
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007052801866447111),
+    value("f64", -13767429405781133000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005122816800851397),
+  ],
+);
+
+// ./test/core/float_misc.wast:446
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022655621734165475),
+    value("f64", 133219932963494700000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017006180103974106),
+  ],
+);
+
+// ./test/core/float_misc.wast:447
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004196304106554003),
+    value("f64", -9789327.297653636),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042866113053139),
+  ],
+);
+
+// ./test/core/float_misc.wast:450
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1038860800000000000000000000),
+    value("f32", 6211079500000),
+  ]),
+  [value("f32", 167259300000000)],
+);
+
+// ./test/core/float_misc.wast:451
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1869033000000000000000000000),
+    value("f32", -112355730000000000000000000000000),
+  ]),
+  [value("f32", -0.00001663496)],
+);
+
+// ./test/core/float_misc.wast:452
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 3290747200000000000000000),
+    value("f32", 0.9064788),
+  ]),
+  [value("f32", 3630252700000000000000000)],
+);
+
+// ./test/core/float_misc.wast:453
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", -908946.56), value("f32", -17034289000)]),
+  [value("f32", 0.000053359818)],
+);
+
+// ./test/core/float_misc.wast:454
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", -0.00000000000024092477),
+    value("f32", -89840810000000000),
+  ]),
+  [value("f32", 0.0000000000000000000000000000026816852)],
+);
+
+// ./test/core/float_misc.wast:455
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 3910973045785834000),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008392730733897136),
+  ]),
+  [
+    value("f64", -46599529638070336000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:456
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.0000000000000000000000000000000000000008379351966732404),
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021077277802048832),
+  ]),
+  [
+    value("f64", -3975538039318286000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:457
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 4561142017854715000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    value("f64", 1500578067736849100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 3039589952.6465592)],
+);
+
+// ./test/core/float_misc.wast:458
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -6236072401827852000000000000000000000000000000000000000),
+    value("f64", 83170632504609900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007497925907299316),
+  ],
+);
+
+// ./test/core/float_misc.wast:459
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009757271330468098),
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035613812243480865),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000002739743575824061),
+  ],
+);
+
+// ./test/core/float_misc.wast:462
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.00000000000000001046256872449641),
+    value("f64", 1.8150892711657447),
+  ]),
+  [value("f64", 0.000000000000000005764217160391678)],
+);
+
+// ./test/core/float_misc.wast:463
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.00000000000000000000000000000022038268106596436),
+    value("f64", -0.0000000000002859803943943555),
+  ]),
+  [value("f64", -0.0000000000000000007706216418530616)],
+);
+
+// ./test/core/float_misc.wast:464
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.0000000000007596539988437179),
+    value("f64", 0.00000000000000000000000000000000021055358831337124),
+  ]),
+  [value("f64", 3607889112357986600000)],
+);
+
+// ./test/core/float_misc.wast:465
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1120696114500866900000000000),
+    value("f64", 159713233802866500000000000000),
+  ]),
+  [value("f64", 0.007016927074960728)],
+);
+
+// ./test/core/float_misc.wast:466
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.0006342142502301953),
+    value("f64", -6391950865520085),
+  ]),
+  [value("f64", -0.00000000000000000009922076429769178)],
+);
+
+// ./test/core/float_misc.wast:469
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.000000000000000000000000000000000000011754944),
+    value("f32", 0.000000000000000000000000000000000000011754942),
+  ]),
+  [value("f32", 1.0000001)],
+);
+
+// ./test/core/float_misc.wast:470
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.000000000000000000000000000000000000011754942),
+    value("f32", 0.000000000000000000000000000000000000011754944),
+  ]),
+  [value("f32", 0.9999999)],
+);
+
+// ./test/core/float_misc.wast:471
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ]),
+  [value("f64", 1.0000000000000002)],
+);
+
+// ./test/core/float_misc.wast:472
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [value("f64", 0.9999999999999998)],
+);
+
+// ./test/core/float_misc.wast:475
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.00000023841856),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0)],
+);
+
+// ./test/core/float_misc.wast:476
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 0.00000023841858),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000000000001)],
+);
+
+// ./test/core/float_misc.wast:477
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.00000000000000044408920985006257),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/float_misc.wast:478
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.0000000000000004440892098500626),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/float_misc.wast:481
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000002938736),
+  ]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/float_misc.wast:482
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1),
+    value("f32", 0.000000000000000000000000000000000000002938737),
+  ]),
+  [value("f32", 340282200000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:483
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+  ]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/float_misc.wast:484
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1),
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000556268464626801),
+  ]),
+  [
+    value("f64", 179769313486231430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:487
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1),
+    value("f32", 85070600000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754942)],
+);
+
+// ./test/core/float_misc.wast:488
+assert_return(
+  () => invoke($0, `f32.div`, [
+    value("f32", 1),
+    value("f32", 85070590000000000000000000000000000000),
+  ]),
+  [value("f32", 0.000000000000000000000000000000000000011754944)],
+);
+
+// ./test/core/float_misc.wast:489
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1),
+    value("f64", 44942328371557910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/float_misc.wast:490
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1),
+    value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/float_misc.wast:500
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 1), value("f32", 3)]),
+  [value("f32", 0.33333334)],
+);
+
+// ./test/core/float_misc.wast:501
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 3), value("f32", 9)]),
+  [value("f32", 0.33333334)],
+);
+
+// ./test/core/float_misc.wast:502
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 9), value("f32", 27)]),
+  [value("f32", 0.33333334)],
+);
+
+// ./test/core/float_misc.wast:503
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 1), value("f64", 3)]),
+  [value("f64", 0.3333333333333333)],
+);
+
+// ./test/core/float_misc.wast:504
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 3), value("f64", 9)]),
+  [value("f64", 0.3333333333333333)],
+);
+
+// ./test/core/float_misc.wast:505
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 9), value("f64", 27)]),
+  [value("f64", 0.3333333333333333)],
+);
+
+// ./test/core/float_misc.wast:508
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 1.0000001), value("f32", 0.99999994)]),
+  [value("f32", 1.0000002)],
+);
+
+// ./test/core/float_misc.wast:509
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 0.99999994), value("f32", 1.0000001)]),
+  [value("f32", 0.9999998)],
+);
+
+// ./test/core/float_misc.wast:510
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 1), value("f32", 0.99999994)]),
+  [value("f32", 1.0000001)],
+);
+
+// ./test/core/float_misc.wast:511
+assert_return(
+  () => invoke($0, `f32.div`, [value("f32", 1), value("f32", 1.0000001)]),
+  [value("f32", 0.9999999)],
+);
+
+// ./test/core/float_misc.wast:512
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 1.0000000000000002),
+    value("f64", 0.9999999999999999),
+  ]),
+  [value("f64", 1.0000000000000004)],
+);
+
+// ./test/core/float_misc.wast:513
+assert_return(
+  () => invoke($0, `f64.div`, [
+    value("f64", 0.9999999999999999),
+    value("f64", 1.0000000000000002),
+  ]),
+  [value("f64", 0.9999999999999997)],
+);
+
+// ./test/core/float_misc.wast:514
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 1), value("f64", 0.9999999999999999)]),
+  [value("f64", 1.0000000000000002)],
+);
+
+// ./test/core/float_misc.wast:515
+assert_return(
+  () => invoke($0, `f64.div`, [value("f64", 1), value("f64", 1.0000000000000002)]),
+  [value("f64", 0.9999999999999998)],
+);
+
+// ./test/core/float_misc.wast:519
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 171)]), [value("f32", 13.076696)]);
+
+// ./test/core/float_misc.wast:520
+assert_return(
+  () => invoke($0, `f32.sqrt`, [value("f32", 0.000000160795)]),
+  [value("f32", 0.00040099252)],
+);
+
+// ./test/core/float_misc.wast:521
+assert_return(() => invoke($0, `f64.sqrt`, [value("f64", 171)]), [value("f64", 13.076696830622021)]);
+
+// ./test/core/float_misc.wast:522
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.000000160795)]),
+  [value("f64", 0.00040099251863345283)],
+);
+
+// ./test/core/float_misc.wast:525
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000004316357580352844),
+  ]),
+  [value("f64", 0.00000000000000000000000020775845543209175)],
+);
+
+// ./test/core/float_misc.wast:526
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 676253300479648500000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 822346216918183800000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:527
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 17485296624861996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 4181542373916829400000000000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:528
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.000000000009593720960603523)]),
+  [value("f64", 0.0000030973732355987585)],
+);
+
+// ./test/core/float_misc.wast:529
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006348452898717835),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000002519613640762773),
+  ],
+);
+
+// ./test/core/float_misc.wast:533
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.9999999999999999)]),
+  [value("f64", 0.9999999999999999)],
+);
+
+// ./test/core/float_misc.wast:536
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.12963942)]), [value("f32", 0.36005473)]);
+
+// ./test/core/float_misc.wast:537
+assert_return(
+  () => invoke($0, `f32.sqrt`, [value("f32", 2345875800000000000000000000000)]),
+  [value("f32", 1531625200000000)],
+);
+
+// ./test/core/float_misc.wast:538
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.078786574)]), [value("f32", 0.28068945)]);
+
+// ./test/core/float_misc.wast:539
+assert_return(
+  () => invoke($0, `f32.sqrt`, [value("f32", 0.00000000000000000000051371026)]),
+  [value("f32", 0.000000000022665177)],
+);
+
+// ./test/core/float_misc.wast:540
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.00090167153)]), [value("f32", 0.030027846)]);
+
+// ./test/core/float_misc.wast:541
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009591922760825561),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009793836204892116),
+  ],
+);
+
+// ./test/core/float_misc.wast:542
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 935787535216400500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 30590644570136150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:543
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 147706699783365580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [value("f64", 12153464517715332000000000000000000000000000000000000000000)],
+);
+
+// ./test/core/float_misc.wast:544
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 48800457180027890000000000000000)]),
+  [value("f64", 6985732401117859)],
+);
+
+// ./test/core/float_misc.wast:545
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 7618977687174540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 2760249569726357000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:548
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 154481010)]), [value("f32", 12429.039)]);
+
+// ./test/core/float_misc.wast:549
+assert_return(
+  () => invoke($0, `f32.sqrt`, [
+    value("f32", 0.00000000000000000000000000000000010471305),
+  ]),
+  [value("f32", 0.00000000000000001023294)],
+);
+
+// ./test/core/float_misc.wast:550
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.00003790637)]), [value("f32", 0.006156815)]);
+
+// ./test/core/float_misc.wast:551
+assert_return(
+  () => invoke($0, `f32.sqrt`, [
+    value("f32", 0.00000000000000000000000000000000000089607535),
+  ]),
+  [value("f32", 0.0000000000000000009466126)],
+);
+
+// ./test/core/float_misc.wast:552
+assert_return(
+  () => invoke($0, `f32.sqrt`, [
+    value("f32", 0.0000000000000000000000000000000000001687712),
+  ]),
+  [value("f32", 0.00000000000000000041081773)],
+);
+
+// ./test/core/float_misc.wast:553
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 316996264378909500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 563024212959717700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:554
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040573669271847993),
+  ]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020142906759414837),
+  ],
+);
+
+// ./test/core/float_misc.wast:555
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.0000000015299861660588838)]),
+  [value("f64", 0.00003911503759500793)],
+);
+
+// ./test/core/float_misc.wast:556
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000002822766928951239),
+  ]),
+  [value("f64", 0.0000000000000000000000000000000000005312971794533864)],
+);
+
+// ./test/core/float_misc.wast:557
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 14375957727045067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 119899782014168260000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:560
+assert_return(
+  () => invoke($0, `f32.sqrt`, [value("f32", 464023420000000000000000000000000000)]),
+  [value("f32", 681192700000000000)],
+);
+
+// ./test/core/float_misc.wast:561
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 47536.133)]), [value("f32", 218.02783)]);
+
+// ./test/core/float_misc.wast:562
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.812613)]), [value("f32", 0.9014505)]);
+
+// ./test/core/float_misc.wast:563
+assert_return(
+  () => invoke($0, `f32.sqrt`, [value("f32", 0.000000000000000000000000009549605)]),
+  [value("f32", 0.00000000000009772208)],
+);
+
+// ./test/core/float_misc.wast:564
+assert_return(
+  () => invoke($0, `f32.sqrt`, [value("f32", 0.000000000000000000000000000068856485)]),
+  [value("f32", 0.000000000000008297981)],
+);
+
+// ./test/core/float_misc.wast:565
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 2349768917495332200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 1532895599020146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:566
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029262574743429683),
+  ]),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000005409489323718985),
+  ],
+);
+
+// ./test/core/float_misc.wast:567
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 377335087484490800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 19425114864126050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:568
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.000000000000035498432023945234)]),
+  [value("f64", 0.00000018841027579180822)],
+);
+
+// ./test/core/float_misc.wast:569
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013747419336166767),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000011724938949165905),
+  ],
+);
+
+// ./test/core/float_misc.wast:572
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015535152663257847),
+  ]),
+  [`canonical_nan`],
+);
+
+// ./test/core/float_misc.wast:573
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 18763296348029700000000000000000)]),
+  [value("f64", 4331662076851067)],
+);
+
+// ./test/core/float_misc.wast:574
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000274405777036165),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000523837548325972),
+  ],
+);
+
+// ./test/core/float_misc.wast:575
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000015613859952920445),
+  ]),
+  [value("f64", 0.0000000000000000000000000000000000000000039514377070783294)],
+);
+
+// ./test/core/float_misc.wast:576
+assert_return(
+  () => invoke($0, `f64.sqrt`, [
+    value("f64", 619303768945071200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    value("f64", 24885814612848646000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/float_misc.wast:579
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 1.0000001)]), [value("f32", 1)]);
+
+// ./test/core/float_misc.wast:580
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 1.0000002)]), [value("f32", 1.0000001)]);
+
+// ./test/core/float_misc.wast:581
+assert_return(() => invoke($0, `f64.sqrt`, [value("f64", 1.0000000000000002)]), [value("f64", 1)]);
+
+// ./test/core/float_misc.wast:582
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 1.0000000000000004)]),
+  [value("f64", 1.0000000000000002)],
+);
+
+// ./test/core/float_misc.wast:585
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.9999999)]), [value("f32", 0.99999994)]);
+
+// ./test/core/float_misc.wast:586
+assert_return(() => invoke($0, `f32.sqrt`, [value("f32", 0.9999998)]), [value("f32", 0.9999999)]);
+
+// ./test/core/float_misc.wast:587
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.9999999999999998)]),
+  [value("f64", 0.9999999999999999)],
+);
+
+// ./test/core/float_misc.wast:588
+assert_return(
+  () => invoke($0, `f64.sqrt`, [value("f64", 0.9999999999999997)]),
+  [value("f64", 0.9999999999999998)],
+);
+
+// ./test/core/float_misc.wast:592
+assert_return(
+  () => invoke($0, `f32.abs`, [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:593
+assert_return(
+  () => invoke($0, `f32.abs`, [bytes("f32", [0xe2, 0xf1, 0x80, 0xff])]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:594
+assert_return(
+  () => invoke($0, `f64.abs`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:595
+assert_return(
+  () => invoke($0, `f64.abs`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:597
+assert_return(
+  () => invoke($0, `f32.neg`, [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0xff])],
+);
+
+// ./test/core/float_misc.wast:598
+assert_return(
+  () => invoke($0, `f32.neg`, [bytes("f32", [0xe2, 0xf1, 0x80, 0xff])]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:599
+assert_return(
+  () => invoke($0, `f64.neg`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff])],
+);
+
+// ./test/core/float_misc.wast:600
+assert_return(
+  () => invoke($0, `f64.neg`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:602
+assert_return(
+  () => invoke($0, `f32.copysign`, [
+    bytes("f32", [0xe2, 0xf1, 0x80, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:603
+assert_return(
+  () => invoke($0, `f32.copysign`, [
+    bytes("f32", [0xe2, 0xf1, 0x80, 0x7f]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0xff])],
+);
+
+// ./test/core/float_misc.wast:604
+assert_return(
+  () => invoke($0, `f32.copysign`, [
+    bytes("f32", [0xe2, 0xf1, 0x80, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:605
+assert_return(
+  () => invoke($0, `f32.copysign`, [
+    bytes("f32", [0xe2, 0xf1, 0x80, 0xff]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+  ]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0xff])],
+);
+
+// ./test/core/float_misc.wast:606
+assert_return(
+  () => invoke($0, `f64.copysign`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:607
+assert_return(
+  () => invoke($0, `f64.copysign`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff])],
+);
+
+// ./test/core/float_misc.wast:608
+assert_return(
+  () => invoke($0, `f64.copysign`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0x7f])],
+);
+
+// ./test/core/float_misc.wast:609
+assert_return(
+  () => invoke($0, `f64.copysign`, [
+    bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [bytes("f64", [0x6b, 0x7a, 0xe2, 0xf1, 0x0, 0x0, 0xf0, 0xff])],
+);
+
+// ./test/core/float_misc.wast:612
+assert_return(() => invoke($0, `f32.ceil`, [value("f32", 0.99999994)]), [value("f32", 1)]);
+
+// ./test/core/float_misc.wast:613
+assert_return(() => invoke($0, `f32.ceil`, [value("f32", 1.0000001)]), [value("f32", 2)]);
+
+// ./test/core/float_misc.wast:614
+assert_return(() => invoke($0, `f64.ceil`, [value("f64", 0.9999999999999999)]), [value("f64", 1)]);
+
+// ./test/core/float_misc.wast:615
+assert_return(() => invoke($0, `f64.ceil`, [value("f64", 1.0000000000000002)]), [value("f64", 2)]);
+
+// ./test/core/float_misc.wast:618
+assert_return(() => invoke($0, `f32.ceil`, [value("f32", 8388607.5)]), [value("f32", 8388608)]);
+
+// ./test/core/float_misc.wast:619
+assert_return(() => invoke($0, `f32.ceil`, [value("f32", -8388607.5)]), [value("f32", -8388607)]);
+
+// ./test/core/float_misc.wast:620
+assert_return(
+  () => invoke($0, `f64.ceil`, [value("f64", 4503599627370495.5)]),
+  [value("f64", 4503599627370496)],
+);
+
+// ./test/core/float_misc.wast:621
+assert_return(
+  () => invoke($0, `f64.ceil`, [value("f64", -4503599627370495.5)]),
+  [value("f64", -4503599627370495)],
+);
+
+// ./test/core/float_misc.wast:625
+assert_return(() => invoke($0, `f32.ceil`, [value("f32", 16777215)]), [value("f32", 16777215)]);
+
+// ./test/core/float_misc.wast:626
+assert_return(() => invoke($0, `f32.ceil`, [value("f32", -16777215)]), [value("f32", -16777215)]);
+
+// ./test/core/float_misc.wast:627
+assert_return(
+  () => invoke($0, `f64.ceil`, [value("f64", 9007199254740991)]),
+  [value("f64", 9007199254740991)],
+);
+
+// ./test/core/float_misc.wast:628
+assert_return(
+  () => invoke($0, `f64.ceil`, [value("f64", -9007199254740991)]),
+  [value("f64", -9007199254740991)],
+);
+
+// ./test/core/float_misc.wast:631
+assert_return(() => invoke($0, `f32.floor`, [value("f32", -0.99999994)]), [value("f32", -1)]);
+
+// ./test/core/float_misc.wast:632
+assert_return(() => invoke($0, `f32.floor`, [value("f32", -1.0000001)]), [value("f32", -2)]);
+
+// ./test/core/float_misc.wast:633
+assert_return(() => invoke($0, `f64.floor`, [value("f64", -0.9999999999999999)]), [value("f64", -1)]);
+
+// ./test/core/float_misc.wast:634
+assert_return(() => invoke($0, `f64.floor`, [value("f64", -1.0000000000000002)]), [value("f64", -2)]);
+
+// ./test/core/float_misc.wast:637
+assert_return(() => invoke($0, `f32.floor`, [value("f32", -8388607.5)]), [value("f32", -8388608)]);
+
+// ./test/core/float_misc.wast:638
+assert_return(() => invoke($0, `f32.floor`, [value("f32", 8388607.5)]), [value("f32", 8388607)]);
+
+// ./test/core/float_misc.wast:639
+assert_return(
+  () => invoke($0, `f64.floor`, [value("f64", -4503599627370495.5)]),
+  [value("f64", -4503599627370496)],
+);
+
+// ./test/core/float_misc.wast:640
+assert_return(
+  () => invoke($0, `f64.floor`, [value("f64", 4503599627370495.5)]),
+  [value("f64", 4503599627370495)],
+);
+
+// ./test/core/float_misc.wast:644
+assert_return(() => invoke($0, `f32.floor`, [value("f32", 88607)]), [value("f32", 88607)]);
+
+// ./test/core/float_misc.wast:645
+assert_return(() => invoke($0, `f64.floor`, [value("f64", 88607)]), [value("f64", 88607)]);
+
+// ./test/core/float_misc.wast:648
+assert_return(() => invoke($0, `f32.trunc`, [value("f32", -8388607.5)]), [value("f32", -8388607)]);
+
+// ./test/core/float_misc.wast:649
+assert_return(() => invoke($0, `f32.trunc`, [value("f32", 8388607.5)]), [value("f32", 8388607)]);
+
+// ./test/core/float_misc.wast:650
+assert_return(
+  () => invoke($0, `f64.trunc`, [value("f64", -4503599627370495.5)]),
+  [value("f64", -4503599627370495)],
+);
+
+// ./test/core/float_misc.wast:651
+assert_return(
+  () => invoke($0, `f64.trunc`, [value("f64", 4503599627370495.5)]),
+  [value("f64", 4503599627370495)],
+);
+
+// ./test/core/float_misc.wast:656
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", 8388609)]), [value("f32", 8388609)]);
+
+// ./test/core/float_misc.wast:657
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", 8388610)]), [value("f32", 8388610)]);
+
+// ./test/core/float_misc.wast:658
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", 0.49999997)]), [value("f32", 0)]);
+
+// ./test/core/float_misc.wast:659
+assert_return(
+  () => invoke($0, `f32.nearest`, [value("f32", 281474960000000)]),
+  [value("f32", 281474960000000)],
+);
+
+// ./test/core/float_misc.wast:660
+assert_return(
+  () => invoke($0, `f64.nearest`, [value("f64", 4503599627370497)]),
+  [value("f64", 4503599627370497)],
+);
+
+// ./test/core/float_misc.wast:661
+assert_return(
+  () => invoke($0, `f64.nearest`, [value("f64", 4503599627370498)]),
+  [value("f64", 4503599627370498)],
+);
+
+// ./test/core/float_misc.wast:662
+assert_return(() => invoke($0, `f64.nearest`, [value("f64", 0.49999999999999994)]), [value("f64", 0)]);
+
+// ./test/core/float_misc.wast:663
+assert_return(
+  () => invoke($0, `f64.nearest`, [value("f64", 81129638414606670000000000000000)]),
+  [value("f64", 81129638414606670000000000000000)],
+);
+
+// ./test/core/float_misc.wast:667
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", 4.5)]), [value("f32", 4)]);
+
+// ./test/core/float_misc.wast:668
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", -4.5)]), [value("f32", -4)]);
+
+// ./test/core/float_misc.wast:669
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", -3.5)]), [value("f32", -4)]);
+
+// ./test/core/float_misc.wast:670
+assert_return(() => invoke($0, `f64.nearest`, [value("f64", 4.5)]), [value("f64", 4)]);
+
+// ./test/core/float_misc.wast:671
+assert_return(() => invoke($0, `f64.nearest`, [value("f64", -4.5)]), [value("f64", -4)]);
+
+// ./test/core/float_misc.wast:672
+assert_return(() => invoke($0, `f64.nearest`, [value("f64", -3.5)]), [value("f64", -4)]);
+
+// ./test/core/float_misc.wast:675
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", -8388607.5)]), [value("f32", -8388608)]);
+
+// ./test/core/float_misc.wast:676
+assert_return(() => invoke($0, `f32.nearest`, [value("f32", 8388607.5)]), [value("f32", 8388608)]);
+
+// ./test/core/float_misc.wast:677
+assert_return(
+  () => invoke($0, `f64.nearest`, [value("f64", -4503599627370495.5)]),
+  [value("f64", -4503599627370496)],
+);
+
+// ./test/core/float_misc.wast:678
+assert_return(
+  () => invoke($0, `f64.nearest`, [value("f64", 4503599627370495.5)]),
+  [value("f64", 4503599627370496)],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/forward.wast.js b/js/src/jit-test/tests/wasm/spec/spec/forward.wast.js
new file mode 100644
index 0000000000..49bd1bda87
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/forward.wast.js
@@ -0,0 +1,45 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/forward.wast
+
+// ./test/core/forward.wast:1
+let $0 = instantiate(`(module
+  (func $$even (export "even") (param $$n i32) (result i32)
+    (if (result i32) (i32.eq (local.get $$n) (i32.const 0))
+      (then (i32.const 1))
+      (else (call $$odd (i32.sub (local.get $$n) (i32.const 1))))
+    )
+  )
+
+  (func $$odd (export "odd") (param $$n i32) (result i32)
+    (if (result i32) (i32.eq (local.get $$n) (i32.const 0))
+      (then (i32.const 0))
+      (else (call $$even (i32.sub (local.get $$n) (i32.const 1))))
+    )
+  )
+)`);
+
+// ./test/core/forward.wast:17
+assert_return(() => invoke($0, `even`, [13]), [value("i32", 0)]);
+
+// ./test/core/forward.wast:18
+assert_return(() => invoke($0, `even`, [20]), [value("i32", 1)]);
+
+// ./test/core/forward.wast:19
+assert_return(() => invoke($0, `odd`, [13]), [value("i32", 1)]);
+
+// ./test/core/forward.wast:20
+assert_return(() => invoke($0, `odd`, [20]), [value("i32", 0)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/func.wast.js b/js/src/jit-test/tests/wasm/spec/spec/func.wast.js
new file mode 100644
index 0000000000..e5c1253de4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/func.wast.js
@@ -0,0 +1,1218 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/func.wast
+
+// ./test/core/func.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (type $$sig (func))
+  (func $$dummy)
+
+  ;; Syntax
+
+  (func)
+  (func (export "f"))
+  (func $$f)
+  (func $$h (export "g"))
+
+  (func (local))
+  (func (local) (local))
+  (func (local i32))
+  (func (local $$x i32))
+  (func (local i32 f64 i64))
+  (func (local i32) (local f64))
+  (func (local i32 f32) (local $$x i64) (local) (local i32 f64))
+
+  (func (param))
+  (func (param) (param))
+  (func (param i32))
+  (func (param $$x i32))
+  (func (param i32 f64 i64))
+  (func (param i32) (param f64))
+  (func (param i32 f32) (param $$x i64) (param) (param i32 f64))
+
+  (func (result))
+  (func (result) (result))
+  (func (result i32) (unreachable))
+  (func (result i32 f64 f32) (unreachable))
+  (func (result i32) (result f64) (unreachable))
+  (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable))
+
+  (type $$sig-1 (func))
+  (type $$sig-2 (func (result i32)))
+  (type $$sig-3 (func (param $$x i32)))
+  (type $$sig-4 (func (param i32 f64 i32) (result i32)))
+
+  (func (export "type-use-1") (type $$sig-1))
+  (func (export "type-use-2") (type $$sig-2) (i32.const 0))
+  (func (export "type-use-3") (type $$sig-3))
+  (func (export "type-use-4") (type $$sig-4) (i32.const 0))
+  (func (export "type-use-5") (type $$sig-2) (result i32) (i32.const 0))
+  (func (export "type-use-6") (type $$sig-3) (param i32))
+  (func (export "type-use-7")
+    (type $$sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0)
+  )
+
+  (func (type $$sig))
+  (func (type $$forward))  ;; forward reference
+
+  (func $$complex
+    (param i32 f32) (param $$x i64) (param) (param i32)
+    (result) (result i32) (result) (result i64 i32)
+    (local f32) (local $$y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+  (func $$complex-sig
+    (type $$sig)
+    (local f32) (local $$y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+
+  (type $$forward (func))
+
+  ;; Typing of locals
+
+  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
+  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
+  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
+  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
+  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
+  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
+  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
+  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
+  (func (export "local-mixed") (result f64)
+    (local f32) (local $$x i32) (local i64 i32) (local) (local f64 i32)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of parameters
+
+  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
+  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
+  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
+  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
+  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
+  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
+  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
+  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
+  (func (export "param-mixed") (param f32 i32) (param) (param $$x i64) (param i32 f64 i32)
+    (result f64)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of results
+
+  (func (export "empty"))
+  (func (export "value-void") (call $$dummy))
+  (func (export "value-i32") (result i32) (i32.const 77))
+  (func (export "value-i64") (result i64) (i64.const 7777))
+  (func (export "value-f32") (result f32) (f32.const 77.7))
+  (func (export "value-f64") (result f64) (f64.const 77.77))
+  (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7))
+  (func (export "value-i32-i32-i32") (result i32 i32 i32)
+    (i32.const 1) (i32.const 2) (i32.const 3)
+  )
+  (func (export "value-block-void") (block (call $$dummy) (call $$dummy)))
+  (func (export "value-block-i32") (result i32)
+    (block (result i32) (call $$dummy) (i32.const 77))
+  )
+  (func (export "value-block-i32-i64") (result i32 i64)
+    (block (result i32 i64) (call $$dummy) (i32.const 1) (i64.const 2))
+  )
+
+  (func (export "return-empty") (return))
+  (func (export "return-i32") (result i32) (return (i32.const 78)))
+  (func (export "return-i64") (result i64) (return (i64.const 7878)))
+  (func (export "return-f32") (result f32) (return (f32.const 78.7)))
+  (func (export "return-f64") (result f64) (return (f64.const 78.78)))
+  (func (export "return-i32-f64") (result i32 f64)
+    (return (i32.const 78) (f64.const 78.78))
+  )
+  (func (export "return-i32-i32-i32") (result i32 i32 i32)
+    (return (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "return-block-i32") (result i32)
+    (return (block (result i32) (call $$dummy) (i32.const 77)))
+  )
+  (func (export "return-block-i32-i64") (result i32 i64)
+    (return (block (result i32 i64) (call $$dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-empty") (br 0))
+  (func (export "break-i32") (result i32) (br 0 (i32.const 79)))
+  (func (export "break-i64") (result i64) (br 0 (i64.const 7979)))
+  (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
+  (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
+  (func (export "break-i32-f64") (result i32 f64)
+    (br 0 (i32.const 79) (f64.const 79.79))
+  )
+  (func (export "break-i32-i32-i32") (result i32 i32 i32)
+    (br 0 (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "break-block-i32") (result i32)
+    (br 0 (block (result i32) (call $$dummy) (i32.const 77)))
+  )
+  (func (export "break-block-i32-i64") (result i32 i64)
+    (br 0 (block (result i32 i64) (call $$dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-br_if-empty") (param i32)
+    (br_if 0 (local.get 0))
+  )
+  (func (export "break-br_if-num") (param i32) (result i32)
+    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
+  )
+  (func (export "break-br_if-num-num") (param i32) (result i32 i64)
+    (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0))))
+    (i32.const 51) (i64.const 52)
+  )
+
+  (func (export "break-br_table-empty") (param i32)
+    (br_table 0 0 0 (local.get 0))
+  )
+  (func (export "break-br_table-num") (param i32) (result i32)
+    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
+  )
+  (func (export "break-br_table-num-num") (param i32) (result i32 i64)
+    (br_table 0 0 (i32.const 50) (i64.const 51) (local.get 0))
+    (i32.const 51) (i64.const 52)
+  )
+  (func (export "break-br_table-nested-empty") (param i32)
+    (block (br_table 0 1 0 (local.get 0)))
+  )
+  (func (export "break-br_table-nested-num") (param i32) (result i32)
+    (i32.add
+      (block (result i32)
+        (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51)
+      )
+      (i32.const 2)
+    )
+  )
+  (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32)
+    (i32.add
+      (block (result i32 i32)
+        (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0))
+        (i32.const 51) (i32.const -3)
+      )
+    )
+    (i32.const 52)
+  )
+
+  ;; Large signatures
+
+  (func (export "large-sig")
+    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
+    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
+    (local.get 5)
+    (local.get 2)
+    (local.get 0)
+    (local.get 8)
+    (local.get 7)
+    (local.get 1)
+    (local.get 3)
+    (local.get 9)
+    (local.get 4)
+    (local.get 6)
+    (local.get 13)
+    (local.get 11)
+    (local.get 15)
+    (local.get 16)
+    (local.get 14)
+    (local.get 12)
+  )
+
+  ;; Default initialization of locals
+
+  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
+)`);
+
+// ./test/core/func.wast:241
+assert_return(() => invoke($0, `type-use-1`, []), []);
+
+// ./test/core/func.wast:242
+assert_return(() => invoke($0, `type-use-2`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:243
+assert_return(() => invoke($0, `type-use-3`, [1]), []);
+
+// ./test/core/func.wast:244
+assert_return(() => invoke($0, `type-use-4`, [1, value("f64", 1), 1]), [value("i32", 0)]);
+
+// ./test/core/func.wast:248
+assert_return(() => invoke($0, `type-use-5`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:249
+assert_return(() => invoke($0, `type-use-6`, [1]), []);
+
+// ./test/core/func.wast:250
+assert_return(() => invoke($0, `type-use-7`, [1, value("f64", 1), 1]), [value("i32", 0)]);
+
+// ./test/core/func.wast:255
+assert_return(() => invoke($0, `local-first-i32`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:256
+assert_return(() => invoke($0, `local-first-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/func.wast:257
+assert_return(() => invoke($0, `local-first-f32`, []), [value("f32", 0)]);
+
+// ./test/core/func.wast:258
+assert_return(() => invoke($0, `local-first-f64`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:259
+assert_return(() => invoke($0, `local-second-i32`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:260
+assert_return(() => invoke($0, `local-second-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/func.wast:261
+assert_return(() => invoke($0, `local-second-f32`, []), [value("f32", 0)]);
+
+// ./test/core/func.wast:262
+assert_return(() => invoke($0, `local-second-f64`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:263
+assert_return(() => invoke($0, `local-mixed`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:265
+assert_return(() => invoke($0, `param-first-i32`, [2, 3]), [value("i32", 2)]);
+
+// ./test/core/func.wast:268
+assert_return(() => invoke($0, `param-first-i64`, [2n, 3n]), [value("i64", 2n)]);
+
+// ./test/core/func.wast:271
+assert_return(
+  () => invoke($0, `param-first-f32`, [value("f32", 2), value("f32", 3)]),
+  [value("f32", 2)],
+);
+
+// ./test/core/func.wast:274
+assert_return(
+  () => invoke($0, `param-first-f64`, [value("f64", 2), value("f64", 3)]),
+  [value("f64", 2)],
+);
+
+// ./test/core/func.wast:277
+assert_return(() => invoke($0, `param-second-i32`, [2, 3]), [value("i32", 3)]);
+
+// ./test/core/func.wast:280
+assert_return(() => invoke($0, `param-second-i64`, [2n, 3n]), [value("i64", 3n)]);
+
+// ./test/core/func.wast:283
+assert_return(
+  () => invoke($0, `param-second-f32`, [value("f32", 2), value("f32", 3)]),
+  [value("f32", 3)],
+);
+
+// ./test/core/func.wast:286
+assert_return(
+  () => invoke($0, `param-second-f64`, [value("f64", 2), value("f64", 3)]),
+  [value("f64", 3)],
+);
+
+// ./test/core/func.wast:290
+assert_return(
+  () => invoke($0, `param-mixed`, [value("f32", 1), 2, 3n, 4, value("f64", 5.5), 6]),
+  [value("f64", 5.5)],
+);
+
+// ./test/core/func.wast:298
+assert_return(() => invoke($0, `empty`, []), []);
+
+// ./test/core/func.wast:299
+assert_return(() => invoke($0, `value-void`, []), []);
+
+// ./test/core/func.wast:300
+assert_return(() => invoke($0, `value-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:301
+assert_return(() => invoke($0, `value-i64`, []), [value("i64", 7777n)]);
+
+// ./test/core/func.wast:302
+assert_return(() => invoke($0, `value-f32`, []), [value("f32", 77.7)]);
+
+// ./test/core/func.wast:303
+assert_return(() => invoke($0, `value-f64`, []), [value("f64", 77.77)]);
+
+// ./test/core/func.wast:304
+assert_return(() => invoke($0, `value-i32-f64`, []), [value("i32", 77), value("f64", 7)]);
+
+// ./test/core/func.wast:305
+assert_return(
+  () => invoke($0, `value-i32-i32-i32`, []),
+  [value("i32", 1), value("i32", 2), value("i32", 3)],
+);
+
+// ./test/core/func.wast:308
+assert_return(() => invoke($0, `value-block-void`, []), []);
+
+// ./test/core/func.wast:309
+assert_return(() => invoke($0, `value-block-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:310
+assert_return(() => invoke($0, `value-block-i32-i64`, []), [value("i32", 1), value("i64", 2n)]);
+
+// ./test/core/func.wast:312
+assert_return(() => invoke($0, `return-empty`, []), []);
+
+// ./test/core/func.wast:313
+assert_return(() => invoke($0, `return-i32`, []), [value("i32", 78)]);
+
+// ./test/core/func.wast:314
+assert_return(() => invoke($0, `return-i64`, []), [value("i64", 7878n)]);
+
+// ./test/core/func.wast:315
+assert_return(() => invoke($0, `return-f32`, []), [value("f32", 78.7)]);
+
+// ./test/core/func.wast:316
+assert_return(() => invoke($0, `return-f64`, []), [value("f64", 78.78)]);
+
+// ./test/core/func.wast:317
+assert_return(() => invoke($0, `return-i32-f64`, []), [value("i32", 78), value("f64", 78.78)]);
+
+// ./test/core/func.wast:318
+assert_return(
+  () => invoke($0, `return-i32-i32-i32`, []),
+  [value("i32", 1), value("i32", 2), value("i32", 3)],
+);
+
+// ./test/core/func.wast:321
+assert_return(() => invoke($0, `return-block-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:322
+assert_return(() => invoke($0, `return-block-i32-i64`, []), [value("i32", 1), value("i64", 2n)]);
+
+// ./test/core/func.wast:324
+assert_return(() => invoke($0, `break-empty`, []), []);
+
+// ./test/core/func.wast:325
+assert_return(() => invoke($0, `break-i32`, []), [value("i32", 79)]);
+
+// ./test/core/func.wast:326
+assert_return(() => invoke($0, `break-i64`, []), [value("i64", 7979n)]);
+
+// ./test/core/func.wast:327
+assert_return(() => invoke($0, `break-f32`, []), [value("f32", 79.9)]);
+
+// ./test/core/func.wast:328
+assert_return(() => invoke($0, `break-f64`, []), [value("f64", 79.79)]);
+
+// ./test/core/func.wast:329
+assert_return(() => invoke($0, `break-i32-f64`, []), [value("i32", 79), value("f64", 79.79)]);
+
+// ./test/core/func.wast:330
+assert_return(
+  () => invoke($0, `break-i32-i32-i32`, []),
+  [value("i32", 1), value("i32", 2), value("i32", 3)],
+);
+
+// ./test/core/func.wast:333
+assert_return(() => invoke($0, `break-block-i32`, []), [value("i32", 77)]);
+
+// ./test/core/func.wast:334
+assert_return(() => invoke($0, `break-block-i32-i64`, []), [value("i32", 1), value("i64", 2n)]);
+
+// ./test/core/func.wast:336
+assert_return(() => invoke($0, `break-br_if-empty`, [0]), []);
+
+// ./test/core/func.wast:337
+assert_return(() => invoke($0, `break-br_if-empty`, [2]), []);
+
+// ./test/core/func.wast:338
+assert_return(() => invoke($0, `break-br_if-num`, [0]), [value("i32", 51)]);
+
+// ./test/core/func.wast:339
+assert_return(() => invoke($0, `break-br_if-num`, [1]), [value("i32", 50)]);
+
+// ./test/core/func.wast:340
+assert_return(() => invoke($0, `break-br_if-num-num`, [0]), [value("i32", 51), value("i64", 52n)]);
+
+// ./test/core/func.wast:343
+assert_return(() => invoke($0, `break-br_if-num-num`, [1]), [value("i32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:347
+assert_return(() => invoke($0, `break-br_table-empty`, [0]), []);
+
+// ./test/core/func.wast:348
+assert_return(() => invoke($0, `break-br_table-empty`, [1]), []);
+
+// ./test/core/func.wast:349
+assert_return(() => invoke($0, `break-br_table-empty`, [5]), []);
+
+// ./test/core/func.wast:350
+assert_return(() => invoke($0, `break-br_table-empty`, [-1]), []);
+
+// ./test/core/func.wast:351
+assert_return(() => invoke($0, `break-br_table-num`, [0]), [value("i32", 50)]);
+
+// ./test/core/func.wast:352
+assert_return(() => invoke($0, `break-br_table-num`, [1]), [value("i32", 50)]);
+
+// ./test/core/func.wast:353
+assert_return(() => invoke($0, `break-br_table-num`, [10]), [value("i32", 50)]);
+
+// ./test/core/func.wast:354
+assert_return(() => invoke($0, `break-br_table-num`, [-100]), [value("i32", 50)]);
+
+// ./test/core/func.wast:355
+assert_return(() => invoke($0, `break-br_table-num-num`, [0]), [value("i32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:358
+assert_return(() => invoke($0, `break-br_table-num-num`, [1]), [value("i32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:361
+assert_return(() => invoke($0, `break-br_table-num-num`, [10]), [value("i32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:364
+assert_return(() => invoke($0, `break-br_table-num-num`, [-100]), [value("i32", 50), value("i64", 51n)]);
+
+// ./test/core/func.wast:367
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [0]), []);
+
+// ./test/core/func.wast:368
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [1]), []);
+
+// ./test/core/func.wast:369
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [3]), []);
+
+// ./test/core/func.wast:370
+assert_return(() => invoke($0, `break-br_table-nested-empty`, [-2]), []);
+
+// ./test/core/func.wast:371
+assert_return(() => invoke($0, `break-br_table-nested-num`, [0]), [value("i32", 52)]);
+
+// ./test/core/func.wast:374
+assert_return(() => invoke($0, `break-br_table-nested-num`, [1]), [value("i32", 50)]);
+
+// ./test/core/func.wast:377
+assert_return(() => invoke($0, `break-br_table-nested-num`, [2]), [value("i32", 52)]);
+
+// ./test/core/func.wast:380
+assert_return(() => invoke($0, `break-br_table-nested-num`, [-3]), [value("i32", 52)]);
+
+// ./test/core/func.wast:383
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [0]),
+  [value("i32", 101), value("i32", 52)],
+);
+
+// ./test/core/func.wast:387
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [1]),
+  [value("i32", 50), value("i32", 51)],
+);
+
+// ./test/core/func.wast:391
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [2]),
+  [value("i32", 101), value("i32", 52)],
+);
+
+// ./test/core/func.wast:395
+assert_return(
+  () => invoke($0, `break-br_table-nested-num-num`, [-3]),
+  [value("i32", 101), value("i32", 52)],
+);
+
+// ./test/core/func.wast:400
+assert_return(
+  () => invoke($0, `large-sig`, [
+    0,
+    1n,
+    value("f32", 2),
+    value("f32", 3),
+    4,
+    value("f64", 5),
+    value("f32", 6),
+    7,
+    8,
+    9,
+    value("f32", 10),
+    value("f64", 11),
+    value("f64", 12),
+    value("f64", 13),
+    14,
+    15,
+    value("f32", 16),
+  ]),
+  [
+    value("f64", 5),
+    value("f32", 2),
+    value("i32", 0),
+    value("i32", 8),
+    value("i32", 7),
+    value("i64", 1n),
+    value("f32", 3),
+    value("i32", 9),
+    value("i32", 4),
+    value("f32", 6),
+    value("f64", 13),
+    value("f64", 11),
+    value("i32", 15),
+    value("f32", 16),
+    value("i32", 14),
+    value("f64", 12),
+  ],
+);
+
+// ./test/core/func.wast:414
+assert_return(() => invoke($0, `init-local-i32`, []), [value("i32", 0)]);
+
+// ./test/core/func.wast:415
+assert_return(() => invoke($0, `init-local-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/func.wast:416
+assert_return(() => invoke($0, `init-local-f32`, []), [value("f32", 0)]);
+
+// ./test/core/func.wast:417
+assert_return(() => invoke($0, `init-local-f64`, []), [value("f64", 0)]);
+
+// ./test/core/func.wast:422
+let $1 = instantiate(`(module
+  (func $$f (result f64) (f64.const 0))  ;; adds implicit type definition
+  (func $$g (param i32))                 ;; reuses explicit type definition
+  (type $$t (func (param i32)))
+
+  (func $$i32->void (type 0))                ;; (param i32)
+  (func $$void->f64 (type 1) (f64.const 0))  ;; (result f64)
+  (func $$check
+    (call $$i32->void (i32.const 0))
+    (drop (call $$void->f64))
+  )
+)`);
+
+// ./test/core/func.wast:435
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (result f64) (f64.const 0))  ;; adds implicit type definition
+    (func $$g (param i32))                 ;; reuses explicit type definition
+    (func $$h (result f64) (f64.const 1))  ;; reuses implicit type definition
+    (type $$t (func (param i32)))
+
+    (func (type 2))  ;; does not exist
+  )`),
+  `unknown type`,
+);
+
+// ./test/core/func.wast:447
+assert_malformed(
+  () => instantiate(`(func $$f (result f64) (f64.const 0)) (func $$g (param i32)) (func $$h (result f64) (f64.const 1)) (type $$t (func (param i32))) (func (type 2) (param i32)) `),
+  `unknown type`,
+);
+
+// ./test/core/func.wast:459
+let $2 = instantiate(`(module
+  (type $$proc (func (result i32)))
+  (type $$sig (func (param i32) (result i32)))
+
+  (func (export "f") (type $$sig)
+    (local $$var i32)
+    (local.get $$var)
+  )
+
+  (func $$g (type $$sig)
+    (local $$var i32)
+    (local.get $$var)
+  )
+  (func (export "g") (type $$sig)
+    (call $$g (local.get 0))
+  )
+
+  (func (export "p") (type $$proc)
+    (local $$var i32)
+    (local.set 0 (i32.const 42))
+    (local.get $$var)
+  )
+)`);
+
+// ./test/core/func.wast:483
+assert_return(() => invoke($2, `f`, [42]), [value("i32", 0)]);
+
+// ./test/core/func.wast:484
+assert_return(() => invoke($2, `g`, [42]), [value("i32", 0)]);
+
+// ./test/core/func.wast:485
+assert_return(() => invoke($2, `p`, []), [value("i32", 42)]);
+
+// ./test/core/func.wast:488
+let $3 = instantiate(`(module
+  (type $$sig (func))
+
+  (func $$empty-sig-1)  ;; should be assigned type $$sig
+  (func $$complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$empty-sig-2)  ;; should be assigned type $$sig
+  (func $$complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32))
+  (func $$complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32))
+
+  (type $$empty-sig-duplicate (func))
+  (type $$complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
+  (table funcref
+    (elem
+      $$complex-sig-3 $$empty-sig-2 $$complex-sig-1 $$complex-sig-3 $$empty-sig-1
+      $$complex-sig-4 $$complex-sig-5
+    )
+  )
+
+  (func (export "signature-explicit-reused")
+    (call_indirect (type $$sig) (i32.const 1))
+    (call_indirect (type $$sig) (i32.const 4))
+  )
+
+  (func (export "signature-implicit-reused")
+    ;; The implicit index 3 in this test depends on the function and
+    ;; type definitions, and may need adapting if they change.
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 0)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 2)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 3)
+    )
+  )
+
+  (func (export "signature-explicit-duplicate")
+    (call_indirect (type $$empty-sig-duplicate) (i32.const 1))
+  )
+
+  (func (export "signature-implicit-duplicate")
+    (call_indirect (type $$complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 5)
+    )
+    (call_indirect (type $$complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 6)
+    )
+  )
+)`);
+
+// ./test/core/func.wast:551
+assert_return(() => invoke($3, `signature-explicit-reused`, []), []);
+
+// ./test/core/func.wast:552
+assert_return(() => invoke($3, `signature-implicit-reused`, []), []);
+
+// ./test/core/func.wast:553
+assert_return(() => invoke($3, `signature-explicit-duplicate`, []), []);
+
+// ./test/core/func.wast:554
+assert_return(() => invoke($3, `signature-implicit-duplicate`, []), []);
+
+// ./test/core/func.wast:559
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (type $$sig) (result i32) (param i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:566
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (param i32) (type $$sig) (result i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:573
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (param i32) (result i32) (type $$sig) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:580
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (result i32) (type $$sig) (param i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:587
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (result i32) (param i32) (type $$sig) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:594
+assert_malformed(
+  () => instantiate(`(func (result i32) (param i32) (i32.const 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:601
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (func (type $$sig) (result i32) (i32.const 0)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:608
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (type $$sig) (result i32) (i32.const 0)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:615
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (type $$sig) (param i32) (i32.const 0)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:622
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (func (type $$sig) (param i32) (result i32) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/func.wast:633
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i64) (local i32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:637
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:641
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:649
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param i32) (result i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:653
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:657
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:665
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:669
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:673
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:677
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:681
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64-i32 (result f64 i32)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:686
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-num (result i32)
+    (nop)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:692
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-nums (result i32 i32)
+    (nop)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:698
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-void
+    (i32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:704
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-void
+    (i32.const 0) (i64.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:710
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-num (result i32)
+    (f32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:716
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-nums (result f32 f32)
+    (f32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:722
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-num (result f32)
+    (f32.const 0) (f32.const 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:729
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-empty-vs-num (result i32)
+    (return)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:735
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-empty-vs-nums (result i32 i32)
+    (return)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:741
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-void-vs-num (result i32)
+    (return (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:747
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-void-vs-nums (result i32 i64)
+    (return (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:753
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-num-vs-num (result i32)
+    (return (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:759
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-last-num-vs-nums (result i64 i64)
+    (return (i64.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:766
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-empty-vs-num (result i32)
+    (return) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:772
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-empty-vs-nums (result i32 i32)
+    (return) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:778
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-partial-vs-nums (result i32 i32)
+    (i32.const 1) (return) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:784
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-void-vs-num (result i32)
+    (return (nop)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:790
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-void-vs-nums (result i32 i32)
+    (return (nop)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:796
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-num-vs-num (result i32)
+    (return (i64.const 1)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:802
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-num-vs-nums (result i32 i32)
+    (return (i64.const 1)) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:808
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-first-num-vs-num (result i32)
+    (return (i64.const 1)) (return (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:814
+assert_invalid(
+  () => instantiate(`(module (func $$type-return-first-num-vs-nums (result i32 i32)
+    (return (i32.const 1)) (return (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:821
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-num (result i32)
+    (br 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:827
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-void-vs-nums (result i32 i32)
+    (br 0)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:833
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-num-vs-num (result i32)
+    (br 0 (f32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:839
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-last-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:845
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-num (result i32)
+    (br 0) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:851
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-void-vs-nums (result i32 i32)
+    (br 0) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:857
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (i32.const 1)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:863
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 1)) (i32.const 1) (i32.const 2)
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:869
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-first-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:876
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-num (result i32)
+    (block (br 1)) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:882
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-empty-vs-nums (result i32 i32)
+    (block (br 1)) (br 0 (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:888
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-num (result i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:894
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-void-vs-nums (result i32 i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:900
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-num-vs-num (result i32)
+    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:906
+assert_invalid(
+  () => instantiate(`(module (func $$type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/func.wast:916
+assert_malformed(() => instantiate(`(func (nop) (local i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:920
+assert_malformed(() => instantiate(`(func (nop) (param i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:924
+assert_malformed(() => instantiate(`(func (nop) (result i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:928
+assert_malformed(() => instantiate(`(func (local i32) (param i32)) `), `unexpected token`);
+
+// ./test/core/func.wast:932
+assert_malformed(
+  () => instantiate(`(func (local i32) (result i32) (local.get 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:936
+assert_malformed(
+  () => instantiate(`(func (result i32) (param i32) (local.get 0)) `),
+  `unexpected token`,
+);
+
+// ./test/core/func.wast:943
+assert_malformed(() => instantiate(`(func $$foo) (func $$foo) `), `duplicate func`);
+
+// ./test/core/func.wast:947
+assert_malformed(
+  () => instantiate(`(import "" "" (func $$foo)) (func $$foo) `),
+  `duplicate func`,
+);
+
+// ./test/core/func.wast:951
+assert_malformed(
+  () => instantiate(`(import "" "" (func $$foo)) (import "" "" (func $$foo)) `),
+  `duplicate func`,
+);
+
+// ./test/core/func.wast:956
+assert_malformed(
+  () => instantiate(`(func (param $$foo i32) (param $$foo i32)) `),
+  `duplicate local`,
+);
+
+// ./test/core/func.wast:958
+assert_malformed(
+  () => instantiate(`(func (param $$foo i32) (local $$foo i32)) `),
+  `duplicate local`,
+);
+
+// ./test/core/func.wast:960
+assert_malformed(
+  () => instantiate(`(func (local $$foo i32) (local $$foo i32)) `),
+  `duplicate local`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/func_ptrs.wast.js b/js/src/jit-test/tests/wasm/spec/spec/func_ptrs.wast.js
new file mode 100644
index 0000000000..b2a46e861e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/func_ptrs.wast.js
@@ -0,0 +1,191 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/func_ptrs.wast
+
+// ./test/core/func_ptrs.wast:1
+let $0 = instantiate(`(module
+  (type    (func))                           ;; 0: void -> void
+  (type $$S (func))                           ;; 1: void -> void
+  (type    (func (param)))                   ;; 2: void -> void
+  (type    (func (result i32)))              ;; 3: void -> i32
+  (type    (func (param) (result i32)))      ;; 4: void -> i32
+  (type $$T (func (param i32) (result i32)))  ;; 5: i32 -> i32
+  (type $$U (func (param i32)))               ;; 6: i32 -> void
+
+  (func $$print (import "spectest" "print_i32") (type 6))
+
+  (func (type 0))
+  (func (type $$S))
+
+  (func (export "one") (type 4) (i32.const 13))
+  (func (export "two") (type $$T) (i32.add (local.get 0) (i32.const 1)))
+
+  ;; Both signature and parameters are allowed (and required to match)
+  ;; since this allows the naming of parameters.
+  (func (export "three") (type $$T) (param $$a i32) (result i32)
+    (i32.sub (local.get 0) (i32.const 2))
+  )
+
+  (func (export "four") (type $$U) (call $$print (local.get 0)))
+)`);
+
+// ./test/core/func_ptrs.wast:27
+assert_return(() => invoke($0, `one`, []), [value("i32", 13)]);
+
+// ./test/core/func_ptrs.wast:28
+assert_return(() => invoke($0, `two`, [13]), [value("i32", 14)]);
+
+// ./test/core/func_ptrs.wast:29
+assert_return(() => invoke($0, `three`, [13]), [value("i32", 11)]);
+
+// ./test/core/func_ptrs.wast:30
+invoke($0, `four`, [83]);
+
+// ./test/core/func_ptrs.wast:32
+assert_invalid(() => instantiate(`(module (elem (i32.const 0)))`), `unknown table`);
+
+// ./test/core/func_ptrs.wast:33
+assert_invalid(
+  () => instantiate(`(module (elem (i32.const 0) 0) (func))`),
+  `unknown table`,
+);
+
+// ./test/core/func_ptrs.wast:35
+assert_invalid(
+  () => instantiate(`(module (table 1 funcref) (elem (i64.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/func_ptrs.wast:39
+assert_invalid(
+  () => instantiate(`(module (table 1 funcref) (elem (i32.ctz (i32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/func_ptrs.wast:43
+assert_invalid(
+  () => instantiate(`(module (table 1 funcref) (elem (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/func_ptrs.wast:48
+assert_invalid(() => instantiate(`(module (func (type 42)))`), `unknown type`);
+
+// ./test/core/func_ptrs.wast:49
+assert_invalid(
+  () => instantiate(`(module (import "spectest" "print_i32" (func (type 43))))`),
+  `unknown type`,
+);
+
+// ./test/core/func_ptrs.wast:51
+let $1 = instantiate(`(module
+  (type $$T (func (param) (result i32)))
+  (type $$U (func (param) (result i32)))
+  (table funcref (elem $$t1 $$t2 $$t3 $$u1 $$u2 $$t1 $$t3))
+
+  (func $$t1 (type $$T) (i32.const 1))
+  (func $$t2 (type $$T) (i32.const 2))
+  (func $$t3 (type $$T) (i32.const 3))
+  (func $$u1 (type $$U) (i32.const 4))
+  (func $$u2 (type $$U) (i32.const 5))
+
+  (func (export "callt") (param $$i i32) (result i32)
+    (call_indirect (type $$T) (local.get $$i))
+  )
+
+  (func (export "callu") (param $$i i32) (result i32)
+    (call_indirect (type $$U) (local.get $$i))
+  )
+)`);
+
+// ./test/core/func_ptrs.wast:71
+assert_return(() => invoke($1, `callt`, [0]), [value("i32", 1)]);
+
+// ./test/core/func_ptrs.wast:72
+assert_return(() => invoke($1, `callt`, [1]), [value("i32", 2)]);
+
+// ./test/core/func_ptrs.wast:73
+assert_return(() => invoke($1, `callt`, [2]), [value("i32", 3)]);
+
+// ./test/core/func_ptrs.wast:74
+assert_return(() => invoke($1, `callt`, [3]), [value("i32", 4)]);
+
+// ./test/core/func_ptrs.wast:75
+assert_return(() => invoke($1, `callt`, [4]), [value("i32", 5)]);
+
+// ./test/core/func_ptrs.wast:76
+assert_return(() => invoke($1, `callt`, [5]), [value("i32", 1)]);
+
+// ./test/core/func_ptrs.wast:77
+assert_return(() => invoke($1, `callt`, [6]), [value("i32", 3)]);
+
+// ./test/core/func_ptrs.wast:78
+assert_trap(() => invoke($1, `callt`, [7]), `undefined element`);
+
+// ./test/core/func_ptrs.wast:79
+assert_trap(() => invoke($1, `callt`, [100]), `undefined element`);
+
+// ./test/core/func_ptrs.wast:80
+assert_trap(() => invoke($1, `callt`, [-1]), `undefined element`);
+
+// ./test/core/func_ptrs.wast:82
+assert_return(() => invoke($1, `callu`, [0]), [value("i32", 1)]);
+
+// ./test/core/func_ptrs.wast:83
+assert_return(() => invoke($1, `callu`, [1]), [value("i32", 2)]);
+
+// ./test/core/func_ptrs.wast:84
+assert_return(() => invoke($1, `callu`, [2]), [value("i32", 3)]);
+
+// ./test/core/func_ptrs.wast:85
+assert_return(() => invoke($1, `callu`, [3]), [value("i32", 4)]);
+
+// ./test/core/func_ptrs.wast:86
+assert_return(() => invoke($1, `callu`, [4]), [value("i32", 5)]);
+
+// ./test/core/func_ptrs.wast:87
+assert_return(() => invoke($1, `callu`, [5]), [value("i32", 1)]);
+
+// ./test/core/func_ptrs.wast:88
+assert_return(() => invoke($1, `callu`, [6]), [value("i32", 3)]);
+
+// ./test/core/func_ptrs.wast:89
+assert_trap(() => invoke($1, `callu`, [7]), `undefined element`);
+
+// ./test/core/func_ptrs.wast:90
+assert_trap(() => invoke($1, `callu`, [100]), `undefined element`);
+
+// ./test/core/func_ptrs.wast:91
+assert_trap(() => invoke($1, `callu`, [-1]), `undefined element`);
+
+// ./test/core/func_ptrs.wast:93
+let $2 = instantiate(`(module
+  (type $$T (func (result i32)))
+  (table funcref (elem 0 1))
+
+  (func $$t1 (type $$T) (i32.const 1))
+  (func $$t2 (type $$T) (i32.const 2))
+
+  (func (export "callt") (param $$i i32) (result i32)
+    (call_indirect (type $$T) (local.get $$i))
+  )
+)`);
+
+// ./test/core/func_ptrs.wast:105
+assert_return(() => invoke($2, `callt`, [0]), [value("i32", 1)]);
+
+// ./test/core/func_ptrs.wast:106
+assert_return(() => invoke($2, `callt`, [1]), [value("i32", 2)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/global.wast.js b/js/src/jit-test/tests/wasm/spec/spec/global.wast.js
new file mode 100644
index 0000000000..759d2939e8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/global.wast.js
@@ -0,0 +1,808 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/global.wast
+
+// ./test/core/global.wast:3
+let $0 = instantiate(`(module
+  (global (import "spectest" "global_i32") i32)
+  (global (import "spectest" "global_i64") i64)
+
+  (global $$a i32 (i32.const -2))
+  (global (;3;) f32 (f32.const -3))
+  (global (;4;) f64 (f64.const -4))
+  (global $$b i64 (i64.const -5))
+
+  (global $$x (mut i32) (i32.const -12))
+  (global (;7;) (mut f32) (f32.const -13))
+  (global (;8;) (mut f64) (f64.const -14))
+  (global $$y (mut i64) (i64.const -15))
+
+  (global $$z1 i32 (global.get 0))
+  (global $$z2 i64 (global.get 1))
+
+  (global $$r externref (ref.null extern))
+  (global $$mr (mut externref) (ref.null extern))
+  (global funcref (ref.null func))
+
+  (func (export "get-a") (result i32) (global.get $$a))
+  (func (export "get-b") (result i64) (global.get $$b))
+  (func (export "get-r") (result externref) (global.get $$r))
+  (func (export "get-mr") (result externref) (global.get $$mr))
+  (func (export "get-x") (result i32) (global.get $$x))
+  (func (export "get-y") (result i64) (global.get $$y))
+  (func (export "get-z1") (result i32) (global.get $$z1))
+  (func (export "get-z2") (result i64) (global.get $$z2))
+  (func (export "set-x") (param i32) (global.set $$x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $$y (local.get 0)))
+  (func (export "set-mr") (param externref) (global.set $$mr (local.get 0)))
+
+  (func (export "get-3") (result f32) (global.get 3))
+  (func (export "get-4") (result f64) (global.get 4))
+  (func (export "get-7") (result f32) (global.get 7))
+  (func (export "get-8") (result f64) (global.get 8))
+  (func (export "set-7") (param f32) (global.set 7 (local.get 0)))
+  (func (export "set-8") (param f64) (global.set 8 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (global.get $$x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (global.get $$x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (global.get $$x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $$x) (call $$dummy) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $$dummy) (global.get $$x) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $$dummy) (call $$dummy) (global.get $$x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $$x)
+      (then (call $$dummy) (i32.const 2))
+      (else (call $$dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $$x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $$x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $$x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $$x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $$x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $$x) (br_table 0 0)
+    )
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (global.get $$x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (global.get $$x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (i32.const 0) (global.get $$x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $$x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $$x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $$x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (global.get $$x))
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $$f (global.get $$x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $$x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (global.get $$x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $$x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $$x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $$x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$x (global.get $$x))
+    (global.get $$x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $$x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $$x) (global.get $$x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+)`);
+
+// ./test/core/global.wast:196
+assert_return(() => invoke($0, `get-a`, []), [value("i32", -2)]);
+
+// ./test/core/global.wast:197
+assert_return(() => invoke($0, `get-b`, []), [value("i64", -5n)]);
+
+// ./test/core/global.wast:198
+assert_return(() => invoke($0, `get-r`, []), [value('externref', null)]);
+
+// ./test/core/global.wast:199
+assert_return(() => invoke($0, `get-mr`, []), [value('externref', null)]);
+
+// ./test/core/global.wast:200
+assert_return(() => invoke($0, `get-x`, []), [value("i32", -12)]);
+
+// ./test/core/global.wast:201
+assert_return(() => invoke($0, `get-y`, []), [value("i64", -15n)]);
+
+// ./test/core/global.wast:202
+assert_return(() => invoke($0, `get-z1`, []), [value("i32", 666)]);
+
+// ./test/core/global.wast:203
+assert_return(() => invoke($0, `get-z2`, []), [value("i64", 666n)]);
+
+// ./test/core/global.wast:205
+assert_return(() => invoke($0, `get-3`, []), [value("f32", -3)]);
+
+// ./test/core/global.wast:206
+assert_return(() => invoke($0, `get-4`, []), [value("f64", -4)]);
+
+// ./test/core/global.wast:207
+assert_return(() => invoke($0, `get-7`, []), [value("f32", -13)]);
+
+// ./test/core/global.wast:208
+assert_return(() => invoke($0, `get-8`, []), [value("f64", -14)]);
+
+// ./test/core/global.wast:210
+assert_return(() => invoke($0, `set-x`, [6]), []);
+
+// ./test/core/global.wast:211
+assert_return(() => invoke($0, `set-y`, [7n]), []);
+
+// ./test/core/global.wast:213
+assert_return(() => invoke($0, `set-7`, [value("f32", 8)]), []);
+
+// ./test/core/global.wast:214
+assert_return(() => invoke($0, `set-8`, [value("f64", 9)]), []);
+
+// ./test/core/global.wast:216
+assert_return(() => invoke($0, `get-x`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:217
+assert_return(() => invoke($0, `get-y`, []), [value("i64", 7n)]);
+
+// ./test/core/global.wast:218
+assert_return(() => invoke($0, `get-7`, []), [value("f32", 8)]);
+
+// ./test/core/global.wast:219
+assert_return(() => invoke($0, `get-8`, []), [value("f64", 9)]);
+
+// ./test/core/global.wast:221
+assert_return(() => invoke($0, `set-7`, [value("f32", 8)]), []);
+
+// ./test/core/global.wast:222
+assert_return(() => invoke($0, `set-8`, [value("f64", 9)]), []);
+
+// ./test/core/global.wast:223
+assert_return(() => invoke($0, `set-mr`, [externref(10)]), []);
+
+// ./test/core/global.wast:225
+assert_return(() => invoke($0, `get-x`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:226
+assert_return(() => invoke($0, `get-y`, []), [value("i64", 7n)]);
+
+// ./test/core/global.wast:227
+assert_return(() => invoke($0, `get-7`, []), [value("f32", 8)]);
+
+// ./test/core/global.wast:228
+assert_return(() => invoke($0, `get-8`, []), [value("f64", 9)]);
+
+// ./test/core/global.wast:229
+assert_return(() => invoke($0, `get-mr`, []), [value('externref', externref(10))]);
+
+// ./test/core/global.wast:231
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:232
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:233
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:235
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:236
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:237
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:239
+assert_return(() => invoke($0, `as-if-condition`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:240
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:241
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:243
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:244
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:246
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:247
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:249
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:250
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 2)]);
+
+// ./test/core/global.wast:251
+assert_trap(() => invoke($0, `as-call_indirect-last`, []), `undefined element`);
+
+// ./test/core/global.wast:253
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/global.wast:254
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/global.wast:255
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:256
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:258
+assert_return(() => invoke($0, `as-call-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:260
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:261
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/global.wast:262
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:264
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 6)]);
+
+// ./test/core/global.wast:265
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 6)]);
+
+// ./test/core/global.wast:266
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 6)]);
+
+// ./test/core/global.wast:268
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 0)]);
+
+// ./test/core/global.wast:269
+assert_return(() => invoke($0, `as-binary-operand`, []), [value("i32", 36)]);
+
+// ./test/core/global.wast:270
+assert_return(() => invoke($0, `as-compare-operand`, []), [value("i32", 1)]);
+
+// ./test/core/global.wast:272
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))`),
+  `global is immutable`,
+);
+
+// ./test/core/global.wast:277
+assert_invalid(
+  () => instantiate(`(module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1))))`),
+  `global is immutable`,
+);
+
+// ./test/core/global.wast:283
+let $1 = instantiate(`(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))`);
+
+// ./test/core/global.wast:284
+let $2 = instantiate(`(module (global (export "a") (mut f32) (f32.const 0)))`);
+
+// ./test/core/global.wast:286
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.neg (f32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:291
+assert_invalid(
+  () => instantiate(`(module (global f32 (local.get 0)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:296
+assert_invalid(
+  () => instantiate(`(module (global f32 (f32.neg (f32.const 1))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:301
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0) (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:306
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.ctz (i32.const 0))))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:311
+assert_invalid(
+  () => instantiate(`(module (global i32 (nop)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:316
+assert_invalid(() => instantiate(`(module (global i32 (f32.const 0)))`), `type mismatch`);
+
+// ./test/core/global.wast:321
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0) (i32.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:326
+assert_invalid(
+  () => instantiate(`(module (global i32 (;empty instruction sequence;)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:331
+assert_invalid(
+  () => instantiate(`(module (global (import "" "") externref) (global funcref (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:336
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (global.get 0) (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:341
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (i32.const 0) (global.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:346
+assert_invalid(
+  () => instantiate(`(module (global i32 (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:351
+assert_invalid(
+  () => instantiate(`(module (global i32 (i32.const 0)) (global i32 (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:355
+assert_invalid(
+  () => instantiate(`(module (global $$g i32 (i32.const 0)) (global i32 (global.get $$g)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:360
+assert_invalid(
+  () => instantiate(`(module (global i32 (global.get 1)) (global i32 (i32.const 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:365
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-i32") i32) (global i32 (global.get 2)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:370
+assert_invalid(
+  () => instantiate(`(module (global (import "test" "global-mut-i32") (mut i32)) (global i32 (global.get 0)))`),
+  `constant expression required`,
+);
+
+// ./test/core/global.wast:375
+let $3 = instantiate(`(module
+  (import "spectest" "global_i32" (global i32))
+)`);
+
+// ./test/core/global.wast:378
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\98\\80\\80\\80\\00"             ;; import section
+      "\\01"                          ;; length 1
+      "\\08\\73\\70\\65\\63\\74\\65\\73\\74"  ;; "spectest"
+      "\\0a\\67\\6c\\6f\\62\\61\\6c\\5f\\69\\33\\32" ;; "global_i32"
+      "\\03"                          ;; GlobalImport
+      "\\7f"                          ;; i32
+      "\\02"                          ;; malformed mutability
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:391
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\98\\80\\80\\80\\00"             ;; import section
+      "\\01"                          ;; length 1
+      "\\08\\73\\70\\65\\63\\74\\65\\73\\74"  ;; "spectest"
+      "\\0a\\67\\6c\\6f\\62\\61\\6c\\5f\\69\\33\\32" ;; "global_i32"
+      "\\03"                          ;; GlobalImport
+      "\\7f"                          ;; i32
+      "\\ff"                          ;; malformed mutability
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:405
+let $4 = instantiate(`(module
+  (global i32 (i32.const 0))
+)`);
+
+// ./test/core/global.wast:408
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\06\\86\\80\\80\\80\\00"  ;; global section
+      "\\01"               ;; length 1
+      "\\7f"               ;; i32
+      "\\02"               ;; malformed mutability
+      "\\41\\00"            ;; i32.const 0
+      "\\0b"               ;; end
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:420
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\06\\86\\80\\80\\80\\00"  ;; global section
+      "\\01"               ;; length 1
+      "\\7f"               ;; i32
+      "\\ff"               ;; malformed mutability
+      "\\41\\00"            ;; i32.const 0
+      "\\0b"               ;; end
+  )`),
+  `malformed mutability`,
+);
+
+// ./test/core/global.wast:434
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (global.get 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:439
+assert_invalid(
+  () => instantiate(`(module
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:447
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (func (result i32) (global.get 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:455
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 2))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:465
+assert_invalid(
+  () => instantiate(`(module (func (i32.const 0) (global.set 0)))`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:470
+assert_invalid(
+  () => instantiate(`(module
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:478
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (func (i32.const 0) (global.set 1))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:486
+assert_invalid(
+  () => instantiate(`(module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 2))
+  )`),
+  `unknown global`,
+);
+
+// ./test/core/global.wast:496
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty
+      (global.set $$x)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:505
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-block
+      (i32.const 0)
+      (block (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:515
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-loop
+      (i32.const 0)
+      (loop (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:525
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:535
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:545
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:555
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:565
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (global.set $$x)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:575
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-return
+      (return (global.set $$x))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:584
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-select
+      (select (global.set $$x) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:593
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-global.set-value-empty-in-call
+      (call 1 (global.set $$x))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:603
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-global.set-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (global.set $$x) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/global.wast:622
+assert_malformed(
+  () => instantiate(`(global $$foo i32 (i32.const 0)) (global $$foo i32 (i32.const 0)) `),
+  `duplicate global`,
+);
+
+// ./test/core/global.wast:626
+assert_malformed(
+  () => instantiate(`(import "" "" (global $$foo i32)) (global $$foo i32 (i32.const 0)) `),
+  `duplicate global`,
+);
+
+// ./test/core/global.wast:630
+assert_malformed(
+  () => instantiate(`(import "" "" (global $$foo i32)) (import "" "" (global $$foo i32)) `),
+  `duplicate global`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/harness/directives.txt b/js/src/jit-test/tests/wasm/spec/spec/harness/directives.txt
new file mode 100644
index 0000000000..d41243abbb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/harness/directives.txt
@@ -0,0 +1 @@
+|jit-test| skip-if: true
\ No newline at end of file
diff --git a/js/src/jit-test/tests/wasm/spec/spec/harness/harness.js b/js/src/jit-test/tests/wasm/spec/spec/harness/harness.js
new file mode 100644
index 0000000000..ba615e05dd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/harness/harness.js
@@ -0,0 +1,360 @@
+"use strict";
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+if (!wasmIsSupported()) {
+  quit();
+}
+
+function bytes(type, bytes) {
+  var typedBuffer = new Uint8Array(bytes);
+  return wasmGlobalFromArrayBuffer(type, typedBuffer.buffer);
+}
+function value(type, value) {
+  return new WebAssembly.Global({
+    value: type,
+    mutable: false,
+  }, value);
+}
+
+function i8x16(elements) {
+  let typedBuffer = new Uint8Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i16x8(elements) {
+  let typedBuffer = new Uint16Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i32x4(elements) {
+  let typedBuffer = new Uint32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function i64x2(elements) {
+  let typedBuffer = new BigUint64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f32x4(elements) {
+  let typedBuffer = new Float32Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+function f64x2(elements) {
+  let typedBuffer = new Float64Array(elements);
+  return wasmGlobalFromArrayBuffer("v128", typedBuffer.buffer);
+}
+
+function either(...arr) {
+  return new EitherVariants(arr);
+}
+
+class F32x4Pattern {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}
+
+class F64x2Pattern {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+let externrefs = {};
+let externsym = Symbol("externref");
+function externref(s) {
+  if (!(s in externrefs)) externrefs[s] = { [externsym]: s };
+  return externrefs[s];
+}
+function is_externref(x) {
+  return (x !== null && externsym in x) ? 1 : 0;
+}
+function is_funcref(x) {
+  return typeof x === "function" ? 1 : 0;
+}
+function eq_externref(x, y) {
+  return x === y ? 1 : 0;
+}
+function eq_funcref(x, y) {
+  return x === y ? 1 : 0;
+}
+
+let spectest = {
+  externref: externref,
+  is_externref: is_externref,
+  is_funcref: is_funcref,
+  eq_externref: eq_externref,
+  eq_funcref: eq_funcref,
+  print: console.log.bind(console),
+  print_i32: 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",
+  }),
+  memory: new WebAssembly.Memory({ initial: 1, maximum: 2 }),
+};
+
+let linkage = {
+  spectest,
+};
+
+function getInstance(instanceish) {
+  if (typeof instanceish === "string") {
+    assertEq(
+      instanceish in linkage,
+      true,
+      `'${instanceish}'' must be registered`,
+    );
+    return linkage[instanceish];
+  }
+  return instanceish;
+}
+
+function instantiate(source) {
+  let bytecode = wasmTextToBinary(source);
+  let module = new WebAssembly.Module(bytecode);
+  let instance = new WebAssembly.Instance(module, linkage);
+  return instance.exports;
+}
+
+function register(instanceish, name) {
+  linkage[name] = getInstance(instanceish);
+}
+
+function invoke(instanceish, field, params) {
+  let func = getInstance(instanceish)[field];
+  assertEq(func instanceof Function, true, "expected a function");
+  return wasmLosslessInvoke(func, ...params);
+}
+
+function get(instanceish, field) {
+  let global = getInstance(instanceish)[field];
+  assertEq(
+    global instanceof WebAssembly.Global,
+    true,
+    "expected a WebAssembly.Global",
+  );
+  return global;
+}
+
+function assert_trap(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "trap");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.RuntimeError,
+      true,
+      "expected trap",
+    );
+  }
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+function assert_exhaustion(thunk, message) {
+  try {
+    thunk();
+    assertEq("normal return", "exhaustion");
+  } catch (err) {
+    assertEq(
+      err instanceof StackOverflow,
+      true,
+      "expected exhaustion",
+    );
+  }
+}
+
+function assert_invalid(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "invalid module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an invalid module",
+    );
+  }
+}
+
+function assert_unlinkable(thunk, message) {
+  try {
+    thunk();
+    assertEq(true, false, "expected an unlinkable module");
+  } catch (err) {
+    assertEq(
+      err instanceof WebAssembly.LinkError ||
+        err instanceof WebAssembly.CompileError,
+      true,
+      "expected an unlinkable module",
+    );
+  }
+}
+
+function assert_malformed(thunk, message) {
+  try {
+    thunk();
+    assertEq("valid module", "malformed module");
+  } catch (err) {
+    assertEq(
+      err instanceof TypeError ||
+        err instanceof SyntaxError ||
+        err instanceof WebAssembly.CompileError ||
+        err instanceof WebAssembly.LinkError,
+      true,
+      `expected a malformed module`,
+    );
+  }
+}
+
+function assert_exception(thunk) {
+  let thrown = false;
+  try {
+    thunk();
+  } catch (err) {
+    thrown = true;
+  }
+  assertEq(thrown, true, "expected an exception to be thrown");
+}
+
+function assert_return(thunk, expected) {
+  let results = thunk();
+
+  if (results === undefined) {
+    results = [];
+  } else if (!Array.isArray(results)) {
+    results = [results];
+  }
+  if (!Array.isArray(expected)) {
+    expected = [expected];
+  }
+
+  if (!compareResults(results, expected)) {
+    let got = results.map((x) => formatResult(x)).join(", ");
+    let wanted = expected.map((x) => formatExpected(x)).join(", ");
+    assertEq(
+      `[${got}]`,
+      `[${wanted}]`,
+    );
+    assertEq(true, false, `${got} !== ${wanted}`);
+  }
+}
+
+function formatResult(result) {
+  if (typeof (result) === "object") {
+    return wasmGlobalToString(result);
+  } else {
+    return `${result}`;
+  }
+}
+
+function formatExpected(expected) {
+  if (
+    expected === `f32_canonical_nan` ||
+    expected === `f32_arithmetic_nan` ||
+    expected === `f64_canonical_nan` ||
+    expected === `f64_arithmetic_nan`
+  ) {
+    return expected;
+  } else if (expected instanceof F32x4Pattern) {
+    return `f32x4(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    }, ${formatExpected(expected.z)}, ${formatExpected(expected.w)})`;
+  } else if (expected instanceof F64x2Pattern) {
+    return `f64x2(${formatExpected(expected.x)}, ${
+      formatExpected(expected.y)
+    })`;
+  } else if (expected instanceof EitherVariants) {
+    return expected.formatExpected();
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalToString(expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
+
+class EitherVariants {
+  constructor(arr) {
+    this.arr = arr;
+  }
+  matches(v) {
+    return this.arr.some((e) => compareResult(v, e));
+  }
+  formatExpected() {
+    return `either(${this.arr.map(formatExpected).join(", ")})`;
+  }
+}
+
+function compareResults(results, expected) {
+  if (results.length !== expected.length) {
+    return false;
+  }
+  for (let i in results) {
+    if (expected[i] instanceof EitherVariants) {
+      return expected[i].matches(results[i]);
+    }
+    if (!compareResult(results[i], expected[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareResult(result, expected) {
+  if (
+    expected === `canonical_nan` ||
+    expected === `arithmetic_nan`
+  ) {
+    return wasmGlobalIsNaN(result, expected);
+  } else if (expected instanceof F32x4Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f32x4", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 1), expected.y) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 2), expected.z) &&
+      compareResult(wasmGlobalExtractLane(result, "f32x4", 3), expected.w);
+  } else if (expected instanceof F64x2Pattern) {
+    return compareResult(
+      wasmGlobalExtractLane(result, "f64x2", 0),
+      expected.x,
+    ) &&
+      compareResult(wasmGlobalExtractLane(result, "f64x2", 1), expected.y);
+  } else if (typeof (expected) === "object") {
+    return wasmGlobalsEqual(result, expected);
+  } else {
+    throw new Error("unknown expected result");
+  }
+}
diff --git a/js/src/jit-test/tests/wasm/spec/spec/i32.wast.js b/js/src/jit-test/tests/wasm/spec/spec/i32.wast.js
new file mode 100644
index 0000000000..b7455c08b1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/i32.wast.js
@@ -0,0 +1,1967 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/i32.wast
+
+// ./test/core/i32.wast:3
+let $0 = instantiate(`(module
+  (func (export "add") (param $$x i32) (param $$y i32) (result i32) (i32.add (local.get $$x) (local.get $$y)))
+  (func (export "sub") (param $$x i32) (param $$y i32) (result i32) (i32.sub (local.get $$x) (local.get $$y)))
+  (func (export "mul") (param $$x i32) (param $$y i32) (result i32) (i32.mul (local.get $$x) (local.get $$y)))
+  (func (export "div_s") (param $$x i32) (param $$y i32) (result i32) (i32.div_s (local.get $$x) (local.get $$y)))
+  (func (export "div_u") (param $$x i32) (param $$y i32) (result i32) (i32.div_u (local.get $$x) (local.get $$y)))
+  (func (export "rem_s") (param $$x i32) (param $$y i32) (result i32) (i32.rem_s (local.get $$x) (local.get $$y)))
+  (func (export "rem_u") (param $$x i32) (param $$y i32) (result i32) (i32.rem_u (local.get $$x) (local.get $$y)))
+  (func (export "and") (param $$x i32) (param $$y i32) (result i32) (i32.and (local.get $$x) (local.get $$y)))
+  (func (export "or") (param $$x i32) (param $$y i32) (result i32) (i32.or (local.get $$x) (local.get $$y)))
+  (func (export "xor") (param $$x i32) (param $$y i32) (result i32) (i32.xor (local.get $$x) (local.get $$y)))
+  (func (export "shl") (param $$x i32) (param $$y i32) (result i32) (i32.shl (local.get $$x) (local.get $$y)))
+  (func (export "shr_s") (param $$x i32) (param $$y i32) (result i32) (i32.shr_s (local.get $$x) (local.get $$y)))
+  (func (export "shr_u") (param $$x i32) (param $$y i32) (result i32) (i32.shr_u (local.get $$x) (local.get $$y)))
+  (func (export "rotl") (param $$x i32) (param $$y i32) (result i32) (i32.rotl (local.get $$x) (local.get $$y)))
+  (func (export "rotr") (param $$x i32) (param $$y i32) (result i32) (i32.rotr (local.get $$x) (local.get $$y)))
+  (func (export "clz") (param $$x i32) (result i32) (i32.clz (local.get $$x)))
+  (func (export "ctz") (param $$x i32) (result i32) (i32.ctz (local.get $$x)))
+  (func (export "popcnt") (param $$x i32) (result i32) (i32.popcnt (local.get $$x)))
+  (func (export "extend8_s") (param $$x i32) (result i32) (i32.extend8_s (local.get $$x)))
+  (func (export "extend16_s") (param $$x i32) (result i32) (i32.extend16_s (local.get $$x)))
+  (func (export "eqz") (param $$x i32) (result i32) (i32.eqz (local.get $$x)))
+  (func (export "eq") (param $$x i32) (param $$y i32) (result i32) (i32.eq (local.get $$x) (local.get $$y)))
+  (func (export "ne") (param $$x i32) (param $$y i32) (result i32) (i32.ne (local.get $$x) (local.get $$y)))
+  (func (export "lt_s") (param $$x i32) (param $$y i32) (result i32) (i32.lt_s (local.get $$x) (local.get $$y)))
+  (func (export "lt_u") (param $$x i32) (param $$y i32) (result i32) (i32.lt_u (local.get $$x) (local.get $$y)))
+  (func (export "le_s") (param $$x i32) (param $$y i32) (result i32) (i32.le_s (local.get $$x) (local.get $$y)))
+  (func (export "le_u") (param $$x i32) (param $$y i32) (result i32) (i32.le_u (local.get $$x) (local.get $$y)))
+  (func (export "gt_s") (param $$x i32) (param $$y i32) (result i32) (i32.gt_s (local.get $$x) (local.get $$y)))
+  (func (export "gt_u") (param $$x i32) (param $$y i32) (result i32) (i32.gt_u (local.get $$x) (local.get $$y)))
+  (func (export "ge_s") (param $$x i32) (param $$y i32) (result i32) (i32.ge_s (local.get $$x) (local.get $$y)))
+  (func (export "ge_u") (param $$x i32) (param $$y i32) (result i32) (i32.ge_u (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/i32.wast:37
+assert_return(() => invoke($0, `add`, [1, 1]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:38
+assert_return(() => invoke($0, `add`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:39
+assert_return(() => invoke($0, `add`, [-1, -1]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:40
+assert_return(() => invoke($0, `add`, [-1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:41
+assert_return(() => invoke($0, `add`, [2147483647, 1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:42
+assert_return(() => invoke($0, `add`, [-2147483648, -1]), [value("i32", 2147483647)]);
+
+// ./test/core/i32.wast:43
+assert_return(() => invoke($0, `add`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:44
+assert_return(() => invoke($0, `add`, [1073741823, 1]), [value("i32", 1073741824)]);
+
+// ./test/core/i32.wast:46
+assert_return(() => invoke($0, `sub`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:47
+assert_return(() => invoke($0, `sub`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:48
+assert_return(() => invoke($0, `sub`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:49
+assert_return(() => invoke($0, `sub`, [2147483647, -1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:50
+assert_return(() => invoke($0, `sub`, [-2147483648, 1]), [value("i32", 2147483647)]);
+
+// ./test/core/i32.wast:51
+assert_return(() => invoke($0, `sub`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:52
+assert_return(() => invoke($0, `sub`, [1073741823, -1]), [value("i32", 1073741824)]);
+
+// ./test/core/i32.wast:54
+assert_return(() => invoke($0, `mul`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:55
+assert_return(() => invoke($0, `mul`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:56
+assert_return(() => invoke($0, `mul`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:57
+assert_return(() => invoke($0, `mul`, [268435456, 4096]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:58
+assert_return(() => invoke($0, `mul`, [-2147483648, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:59
+assert_return(() => invoke($0, `mul`, [-2147483648, -1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:60
+assert_return(() => invoke($0, `mul`, [2147483647, -1]), [value("i32", -2147483647)]);
+
+// ./test/core/i32.wast:61
+assert_return(() => invoke($0, `mul`, [19088743, 1985229328]), [value("i32", 898528368)]);
+
+// ./test/core/i32.wast:62
+assert_return(() => invoke($0, `mul`, [2147483647, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:64
+assert_trap(() => invoke($0, `div_s`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:65
+assert_trap(() => invoke($0, `div_s`, [0, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:66
+assert_trap(() => invoke($0, `div_s`, [-2147483648, -1]), `integer overflow`);
+
+// ./test/core/i32.wast:67
+assert_trap(() => invoke($0, `div_s`, [-2147483648, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:68
+assert_return(() => invoke($0, `div_s`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:69
+assert_return(() => invoke($0, `div_s`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:70
+assert_return(() => invoke($0, `div_s`, [0, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:71
+assert_return(() => invoke($0, `div_s`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:72
+assert_return(() => invoke($0, `div_s`, [-2147483648, 2]), [value("i32", -1073741824)]);
+
+// ./test/core/i32.wast:73
+assert_return(() => invoke($0, `div_s`, [-2147483647, 1000]), [value("i32", -2147483)]);
+
+// ./test/core/i32.wast:74
+assert_return(() => invoke($0, `div_s`, [5, 2]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:75
+assert_return(() => invoke($0, `div_s`, [-5, 2]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:76
+assert_return(() => invoke($0, `div_s`, [5, -2]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:77
+assert_return(() => invoke($0, `div_s`, [-5, -2]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:78
+assert_return(() => invoke($0, `div_s`, [7, 3]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:79
+assert_return(() => invoke($0, `div_s`, [-7, 3]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:80
+assert_return(() => invoke($0, `div_s`, [7, -3]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:81
+assert_return(() => invoke($0, `div_s`, [-7, -3]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:82
+assert_return(() => invoke($0, `div_s`, [11, 5]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:83
+assert_return(() => invoke($0, `div_s`, [17, 7]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:85
+assert_trap(() => invoke($0, `div_u`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:86
+assert_trap(() => invoke($0, `div_u`, [0, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:87
+assert_return(() => invoke($0, `div_u`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:88
+assert_return(() => invoke($0, `div_u`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:89
+assert_return(() => invoke($0, `div_u`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:90
+assert_return(() => invoke($0, `div_u`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:91
+assert_return(() => invoke($0, `div_u`, [-2147483648, 2]), [value("i32", 1073741824)]);
+
+// ./test/core/i32.wast:92
+assert_return(() => invoke($0, `div_u`, [-1880092688, 65537]), [value("i32", 36847)]);
+
+// ./test/core/i32.wast:93
+assert_return(() => invoke($0, `div_u`, [-2147483647, 1000]), [value("i32", 2147483)]);
+
+// ./test/core/i32.wast:94
+assert_return(() => invoke($0, `div_u`, [5, 2]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:95
+assert_return(() => invoke($0, `div_u`, [-5, 2]), [value("i32", 2147483645)]);
+
+// ./test/core/i32.wast:96
+assert_return(() => invoke($0, `div_u`, [5, -2]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:97
+assert_return(() => invoke($0, `div_u`, [-5, -2]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:98
+assert_return(() => invoke($0, `div_u`, [7, 3]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:99
+assert_return(() => invoke($0, `div_u`, [11, 5]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:100
+assert_return(() => invoke($0, `div_u`, [17, 7]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:102
+assert_trap(() => invoke($0, `rem_s`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:103
+assert_trap(() => invoke($0, `rem_s`, [0, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:104
+assert_return(() => invoke($0, `rem_s`, [2147483647, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:105
+assert_return(() => invoke($0, `rem_s`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:106
+assert_return(() => invoke($0, `rem_s`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:107
+assert_return(() => invoke($0, `rem_s`, [0, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:108
+assert_return(() => invoke($0, `rem_s`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:109
+assert_return(() => invoke($0, `rem_s`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:110
+assert_return(() => invoke($0, `rem_s`, [-2147483648, 2]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:111
+assert_return(() => invoke($0, `rem_s`, [-2147483647, 1000]), [value("i32", -647)]);
+
+// ./test/core/i32.wast:112
+assert_return(() => invoke($0, `rem_s`, [5, 2]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:113
+assert_return(() => invoke($0, `rem_s`, [-5, 2]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:114
+assert_return(() => invoke($0, `rem_s`, [5, -2]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:115
+assert_return(() => invoke($0, `rem_s`, [-5, -2]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:116
+assert_return(() => invoke($0, `rem_s`, [7, 3]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:117
+assert_return(() => invoke($0, `rem_s`, [-7, 3]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:118
+assert_return(() => invoke($0, `rem_s`, [7, -3]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:119
+assert_return(() => invoke($0, `rem_s`, [-7, -3]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:120
+assert_return(() => invoke($0, `rem_s`, [11, 5]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:121
+assert_return(() => invoke($0, `rem_s`, [17, 7]), [value("i32", 3)]);
+
+// ./test/core/i32.wast:123
+assert_trap(() => invoke($0, `rem_u`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:124
+assert_trap(() => invoke($0, `rem_u`, [0, 0]), `integer divide by zero`);
+
+// ./test/core/i32.wast:125
+assert_return(() => invoke($0, `rem_u`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:126
+assert_return(() => invoke($0, `rem_u`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:127
+assert_return(() => invoke($0, `rem_u`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:128
+assert_return(() => invoke($0, `rem_u`, [-2147483648, -1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:129
+assert_return(() => invoke($0, `rem_u`, [-2147483648, 2]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:130
+assert_return(() => invoke($0, `rem_u`, [-1880092688, 65537]), [value("i32", 32769)]);
+
+// ./test/core/i32.wast:131
+assert_return(() => invoke($0, `rem_u`, [-2147483647, 1000]), [value("i32", 649)]);
+
+// ./test/core/i32.wast:132
+assert_return(() => invoke($0, `rem_u`, [5, 2]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:133
+assert_return(() => invoke($0, `rem_u`, [-5, 2]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:134
+assert_return(() => invoke($0, `rem_u`, [5, -2]), [value("i32", 5)]);
+
+// ./test/core/i32.wast:135
+assert_return(() => invoke($0, `rem_u`, [-5, -2]), [value("i32", -5)]);
+
+// ./test/core/i32.wast:136
+assert_return(() => invoke($0, `rem_u`, [7, 3]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:137
+assert_return(() => invoke($0, `rem_u`, [11, 5]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:138
+assert_return(() => invoke($0, `rem_u`, [17, 7]), [value("i32", 3)]);
+
+// ./test/core/i32.wast:140
+assert_return(() => invoke($0, `and`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:141
+assert_return(() => invoke($0, `and`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:142
+assert_return(() => invoke($0, `and`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:143
+assert_return(() => invoke($0, `and`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:144
+assert_return(() => invoke($0, `and`, [2147483647, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:145
+assert_return(() => invoke($0, `and`, [2147483647, -1]), [value("i32", 2147483647)]);
+
+// ./test/core/i32.wast:146
+assert_return(() => invoke($0, `and`, [-252641281, -3856]), [value("i32", -252645136)]);
+
+// ./test/core/i32.wast:147
+assert_return(() => invoke($0, `and`, [-1, -1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:149
+assert_return(() => invoke($0, `or`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:150
+assert_return(() => invoke($0, `or`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:151
+assert_return(() => invoke($0, `or`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:152
+assert_return(() => invoke($0, `or`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:153
+assert_return(() => invoke($0, `or`, [2147483647, -2147483648]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:154
+assert_return(() => invoke($0, `or`, [-2147483648, 0]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:155
+assert_return(() => invoke($0, `or`, [-252641281, -3856]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:156
+assert_return(() => invoke($0, `or`, [-1, -1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:158
+assert_return(() => invoke($0, `xor`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:159
+assert_return(() => invoke($0, `xor`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:160
+assert_return(() => invoke($0, `xor`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:161
+assert_return(() => invoke($0, `xor`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:162
+assert_return(() => invoke($0, `xor`, [2147483647, -2147483648]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:163
+assert_return(() => invoke($0, `xor`, [-2147483648, 0]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:164
+assert_return(() => invoke($0, `xor`, [-1, -2147483648]), [value("i32", 2147483647)]);
+
+// ./test/core/i32.wast:165
+assert_return(() => invoke($0, `xor`, [-1, 2147483647]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:166
+assert_return(() => invoke($0, `xor`, [-252641281, -3856]), [value("i32", 252645135)]);
+
+// ./test/core/i32.wast:167
+assert_return(() => invoke($0, `xor`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:169
+assert_return(() => invoke($0, `shl`, [1, 1]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:170
+assert_return(() => invoke($0, `shl`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:171
+assert_return(() => invoke($0, `shl`, [2147483647, 1]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:172
+assert_return(() => invoke($0, `shl`, [-1, 1]), [value("i32", -2)]);
+
+// ./test/core/i32.wast:173
+assert_return(() => invoke($0, `shl`, [-2147483648, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:174
+assert_return(() => invoke($0, `shl`, [1073741824, 1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:175
+assert_return(() => invoke($0, `shl`, [1, 31]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:176
+assert_return(() => invoke($0, `shl`, [1, 32]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:177
+assert_return(() => invoke($0, `shl`, [1, 33]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:178
+assert_return(() => invoke($0, `shl`, [1, -1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:179
+assert_return(() => invoke($0, `shl`, [1, 2147483647]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:181
+assert_return(() => invoke($0, `shr_s`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:182
+assert_return(() => invoke($0, `shr_s`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:183
+assert_return(() => invoke($0, `shr_s`, [-1, 1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:184
+assert_return(() => invoke($0, `shr_s`, [2147483647, 1]), [value("i32", 1073741823)]);
+
+// ./test/core/i32.wast:185
+assert_return(() => invoke($0, `shr_s`, [-2147483648, 1]), [value("i32", -1073741824)]);
+
+// ./test/core/i32.wast:186
+assert_return(() => invoke($0, `shr_s`, [1073741824, 1]), [value("i32", 536870912)]);
+
+// ./test/core/i32.wast:187
+assert_return(() => invoke($0, `shr_s`, [1, 32]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:188
+assert_return(() => invoke($0, `shr_s`, [1, 33]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:189
+assert_return(() => invoke($0, `shr_s`, [1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:190
+assert_return(() => invoke($0, `shr_s`, [1, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:191
+assert_return(() => invoke($0, `shr_s`, [1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:192
+assert_return(() => invoke($0, `shr_s`, [-2147483648, 31]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:193
+assert_return(() => invoke($0, `shr_s`, [-1, 32]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:194
+assert_return(() => invoke($0, `shr_s`, [-1, 33]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:195
+assert_return(() => invoke($0, `shr_s`, [-1, -1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:196
+assert_return(() => invoke($0, `shr_s`, [-1, 2147483647]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:197
+assert_return(() => invoke($0, `shr_s`, [-1, -2147483648]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:199
+assert_return(() => invoke($0, `shr_u`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:200
+assert_return(() => invoke($0, `shr_u`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:201
+assert_return(() => invoke($0, `shr_u`, [-1, 1]), [value("i32", 2147483647)]);
+
+// ./test/core/i32.wast:202
+assert_return(() => invoke($0, `shr_u`, [2147483647, 1]), [value("i32", 1073741823)]);
+
+// ./test/core/i32.wast:203
+assert_return(() => invoke($0, `shr_u`, [-2147483648, 1]), [value("i32", 1073741824)]);
+
+// ./test/core/i32.wast:204
+assert_return(() => invoke($0, `shr_u`, [1073741824, 1]), [value("i32", 536870912)]);
+
+// ./test/core/i32.wast:205
+assert_return(() => invoke($0, `shr_u`, [1, 32]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:206
+assert_return(() => invoke($0, `shr_u`, [1, 33]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:207
+assert_return(() => invoke($0, `shr_u`, [1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:208
+assert_return(() => invoke($0, `shr_u`, [1, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:209
+assert_return(() => invoke($0, `shr_u`, [1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:210
+assert_return(() => invoke($0, `shr_u`, [-2147483648, 31]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:211
+assert_return(() => invoke($0, `shr_u`, [-1, 32]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:212
+assert_return(() => invoke($0, `shr_u`, [-1, 33]), [value("i32", 2147483647)]);
+
+// ./test/core/i32.wast:213
+assert_return(() => invoke($0, `shr_u`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:214
+assert_return(() => invoke($0, `shr_u`, [-1, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:215
+assert_return(() => invoke($0, `shr_u`, [-1, -2147483648]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:217
+assert_return(() => invoke($0, `rotl`, [1, 1]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:218
+assert_return(() => invoke($0, `rotl`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:219
+assert_return(() => invoke($0, `rotl`, [-1, 1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:220
+assert_return(() => invoke($0, `rotl`, [1, 32]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:221
+assert_return(() => invoke($0, `rotl`, [-1412589450, 1]), [value("i32", 1469788397)]);
+
+// ./test/core/i32.wast:222
+assert_return(() => invoke($0, `rotl`, [-33498112, 4]), [value("i32", -535969777)]);
+
+// ./test/core/i32.wast:223
+assert_return(() => invoke($0, `rotl`, [-1329474845, 5]), [value("i32", 406477942)]);
+
+// ./test/core/i32.wast:224
+assert_return(() => invoke($0, `rotl`, [32768, 37]), [value("i32", 1048576)]);
+
+// ./test/core/i32.wast:225
+assert_return(() => invoke($0, `rotl`, [-1329474845, 65285]), [value("i32", 406477942)]);
+
+// ./test/core/i32.wast:226
+assert_return(() => invoke($0, `rotl`, [1989852383, -19]), [value("i32", 1469837011)]);
+
+// ./test/core/i32.wast:227
+assert_return(() => invoke($0, `rotl`, [1989852383, -2147483635]), [value("i32", 1469837011)]);
+
+// ./test/core/i32.wast:228
+assert_return(() => invoke($0, `rotl`, [1, 31]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:229
+assert_return(() => invoke($0, `rotl`, [-2147483648, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:231
+assert_return(() => invoke($0, `rotr`, [1, 1]), [value("i32", -2147483648)]);
+
+// ./test/core/i32.wast:232
+assert_return(() => invoke($0, `rotr`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:233
+assert_return(() => invoke($0, `rotr`, [-1, 1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:234
+assert_return(() => invoke($0, `rotr`, [1, 32]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:235
+assert_return(() => invoke($0, `rotr`, [-16724992, 1]), [value("i32", 2139121152)]);
+
+// ./test/core/i32.wast:236
+assert_return(() => invoke($0, `rotr`, [524288, 4]), [value("i32", 32768)]);
+
+// ./test/core/i32.wast:237
+assert_return(() => invoke($0, `rotr`, [-1329474845, 5]), [value("i32", 495324823)]);
+
+// ./test/core/i32.wast:238
+assert_return(() => invoke($0, `rotr`, [32768, 37]), [value("i32", 1024)]);
+
+// ./test/core/i32.wast:239
+assert_return(() => invoke($0, `rotr`, [-1329474845, 65285]), [value("i32", 495324823)]);
+
+// ./test/core/i32.wast:240
+assert_return(() => invoke($0, `rotr`, [1989852383, -19]), [value("i32", -419711787)]);
+
+// ./test/core/i32.wast:241
+assert_return(() => invoke($0, `rotr`, [1989852383, -2147483635]), [value("i32", -419711787)]);
+
+// ./test/core/i32.wast:242
+assert_return(() => invoke($0, `rotr`, [1, 31]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:243
+assert_return(() => invoke($0, `rotr`, [-2147483648, 31]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:245
+assert_return(() => invoke($0, `clz`, [-1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:246
+assert_return(() => invoke($0, `clz`, [0]), [value("i32", 32)]);
+
+// ./test/core/i32.wast:247
+assert_return(() => invoke($0, `clz`, [32768]), [value("i32", 16)]);
+
+// ./test/core/i32.wast:248
+assert_return(() => invoke($0, `clz`, [255]), [value("i32", 24)]);
+
+// ./test/core/i32.wast:249
+assert_return(() => invoke($0, `clz`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:250
+assert_return(() => invoke($0, `clz`, [1]), [value("i32", 31)]);
+
+// ./test/core/i32.wast:251
+assert_return(() => invoke($0, `clz`, [2]), [value("i32", 30)]);
+
+// ./test/core/i32.wast:252
+assert_return(() => invoke($0, `clz`, [2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:254
+assert_return(() => invoke($0, `ctz`, [-1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:255
+assert_return(() => invoke($0, `ctz`, [0]), [value("i32", 32)]);
+
+// ./test/core/i32.wast:256
+assert_return(() => invoke($0, `ctz`, [32768]), [value("i32", 15)]);
+
+// ./test/core/i32.wast:257
+assert_return(() => invoke($0, `ctz`, [65536]), [value("i32", 16)]);
+
+// ./test/core/i32.wast:258
+assert_return(() => invoke($0, `ctz`, [-2147483648]), [value("i32", 31)]);
+
+// ./test/core/i32.wast:259
+assert_return(() => invoke($0, `ctz`, [2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:261
+assert_return(() => invoke($0, `popcnt`, [-1]), [value("i32", 32)]);
+
+// ./test/core/i32.wast:262
+assert_return(() => invoke($0, `popcnt`, [0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:263
+assert_return(() => invoke($0, `popcnt`, [32768]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:264
+assert_return(() => invoke($0, `popcnt`, [-2147450880]), [value("i32", 2)]);
+
+// ./test/core/i32.wast:265
+assert_return(() => invoke($0, `popcnt`, [2147483647]), [value("i32", 31)]);
+
+// ./test/core/i32.wast:266
+assert_return(() => invoke($0, `popcnt`, [-1431655766]), [value("i32", 16)]);
+
+// ./test/core/i32.wast:267
+assert_return(() => invoke($0, `popcnt`, [1431655765]), [value("i32", 16)]);
+
+// ./test/core/i32.wast:268
+assert_return(() => invoke($0, `popcnt`, [-559038737]), [value("i32", 24)]);
+
+// ./test/core/i32.wast:270
+assert_return(() => invoke($0, `extend8_s`, [0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:271
+assert_return(() => invoke($0, `extend8_s`, [127]), [value("i32", 127)]);
+
+// ./test/core/i32.wast:272
+assert_return(() => invoke($0, `extend8_s`, [128]), [value("i32", -128)]);
+
+// ./test/core/i32.wast:273
+assert_return(() => invoke($0, `extend8_s`, [255]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:274
+assert_return(() => invoke($0, `extend8_s`, [19088640]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:275
+assert_return(() => invoke($0, `extend8_s`, [-19088768]), [value("i32", -128)]);
+
+// ./test/core/i32.wast:276
+assert_return(() => invoke($0, `extend8_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:278
+assert_return(() => invoke($0, `extend16_s`, [0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:279
+assert_return(() => invoke($0, `extend16_s`, [32767]), [value("i32", 32767)]);
+
+// ./test/core/i32.wast:280
+assert_return(() => invoke($0, `extend16_s`, [32768]), [value("i32", -32768)]);
+
+// ./test/core/i32.wast:281
+assert_return(() => invoke($0, `extend16_s`, [65535]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:282
+assert_return(() => invoke($0, `extend16_s`, [19070976]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:283
+assert_return(() => invoke($0, `extend16_s`, [-19103744]), [value("i32", -32768)]);
+
+// ./test/core/i32.wast:284
+assert_return(() => invoke($0, `extend16_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/i32.wast:286
+assert_return(() => invoke($0, `eqz`, [0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:287
+assert_return(() => invoke($0, `eqz`, [1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:288
+assert_return(() => invoke($0, `eqz`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:289
+assert_return(() => invoke($0, `eqz`, [2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:290
+assert_return(() => invoke($0, `eqz`, [-1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:292
+assert_return(() => invoke($0, `eq`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:293
+assert_return(() => invoke($0, `eq`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:294
+assert_return(() => invoke($0, `eq`, [-1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:295
+assert_return(() => invoke($0, `eq`, [-2147483648, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:296
+assert_return(() => invoke($0, `eq`, [2147483647, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:297
+assert_return(() => invoke($0, `eq`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:298
+assert_return(() => invoke($0, `eq`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:299
+assert_return(() => invoke($0, `eq`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:300
+assert_return(() => invoke($0, `eq`, [-2147483648, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:301
+assert_return(() => invoke($0, `eq`, [0, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:302
+assert_return(() => invoke($0, `eq`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:303
+assert_return(() => invoke($0, `eq`, [-1, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:304
+assert_return(() => invoke($0, `eq`, [-2147483648, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:305
+assert_return(() => invoke($0, `eq`, [2147483647, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:307
+assert_return(() => invoke($0, `ne`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:308
+assert_return(() => invoke($0, `ne`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:309
+assert_return(() => invoke($0, `ne`, [-1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:310
+assert_return(() => invoke($0, `ne`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:311
+assert_return(() => invoke($0, `ne`, [2147483647, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:312
+assert_return(() => invoke($0, `ne`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:313
+assert_return(() => invoke($0, `ne`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:314
+assert_return(() => invoke($0, `ne`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:315
+assert_return(() => invoke($0, `ne`, [-2147483648, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:316
+assert_return(() => invoke($0, `ne`, [0, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:317
+assert_return(() => invoke($0, `ne`, [-2147483648, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:318
+assert_return(() => invoke($0, `ne`, [-1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:319
+assert_return(() => invoke($0, `ne`, [-2147483648, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:320
+assert_return(() => invoke($0, `ne`, [2147483647, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:322
+assert_return(() => invoke($0, `lt_s`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:323
+assert_return(() => invoke($0, `lt_s`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:324
+assert_return(() => invoke($0, `lt_s`, [-1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:325
+assert_return(() => invoke($0, `lt_s`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:326
+assert_return(() => invoke($0, `lt_s`, [2147483647, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:327
+assert_return(() => invoke($0, `lt_s`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:328
+assert_return(() => invoke($0, `lt_s`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:329
+assert_return(() => invoke($0, `lt_s`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:330
+assert_return(() => invoke($0, `lt_s`, [-2147483648, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:331
+assert_return(() => invoke($0, `lt_s`, [0, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:332
+assert_return(() => invoke($0, `lt_s`, [-2147483648, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:333
+assert_return(() => invoke($0, `lt_s`, [-1, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:334
+assert_return(() => invoke($0, `lt_s`, [-2147483648, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:335
+assert_return(() => invoke($0, `lt_s`, [2147483647, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:337
+assert_return(() => invoke($0, `lt_u`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:338
+assert_return(() => invoke($0, `lt_u`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:339
+assert_return(() => invoke($0, `lt_u`, [-1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:340
+assert_return(() => invoke($0, `lt_u`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:341
+assert_return(() => invoke($0, `lt_u`, [2147483647, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:342
+assert_return(() => invoke($0, `lt_u`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:343
+assert_return(() => invoke($0, `lt_u`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:344
+assert_return(() => invoke($0, `lt_u`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:345
+assert_return(() => invoke($0, `lt_u`, [-2147483648, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:346
+assert_return(() => invoke($0, `lt_u`, [0, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:347
+assert_return(() => invoke($0, `lt_u`, [-2147483648, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:348
+assert_return(() => invoke($0, `lt_u`, [-1, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:349
+assert_return(() => invoke($0, `lt_u`, [-2147483648, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:350
+assert_return(() => invoke($0, `lt_u`, [2147483647, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:352
+assert_return(() => invoke($0, `le_s`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:353
+assert_return(() => invoke($0, `le_s`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:354
+assert_return(() => invoke($0, `le_s`, [-1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:355
+assert_return(() => invoke($0, `le_s`, [-2147483648, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:356
+assert_return(() => invoke($0, `le_s`, [2147483647, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:357
+assert_return(() => invoke($0, `le_s`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:358
+assert_return(() => invoke($0, `le_s`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:359
+assert_return(() => invoke($0, `le_s`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:360
+assert_return(() => invoke($0, `le_s`, [-2147483648, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:361
+assert_return(() => invoke($0, `le_s`, [0, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:362
+assert_return(() => invoke($0, `le_s`, [-2147483648, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:363
+assert_return(() => invoke($0, `le_s`, [-1, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:364
+assert_return(() => invoke($0, `le_s`, [-2147483648, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:365
+assert_return(() => invoke($0, `le_s`, [2147483647, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:367
+assert_return(() => invoke($0, `le_u`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:368
+assert_return(() => invoke($0, `le_u`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:369
+assert_return(() => invoke($0, `le_u`, [-1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:370
+assert_return(() => invoke($0, `le_u`, [-2147483648, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:371
+assert_return(() => invoke($0, `le_u`, [2147483647, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:372
+assert_return(() => invoke($0, `le_u`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:373
+assert_return(() => invoke($0, `le_u`, [1, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:374
+assert_return(() => invoke($0, `le_u`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:375
+assert_return(() => invoke($0, `le_u`, [-2147483648, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:376
+assert_return(() => invoke($0, `le_u`, [0, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:377
+assert_return(() => invoke($0, `le_u`, [-2147483648, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:378
+assert_return(() => invoke($0, `le_u`, [-1, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:379
+assert_return(() => invoke($0, `le_u`, [-2147483648, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:380
+assert_return(() => invoke($0, `le_u`, [2147483647, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:382
+assert_return(() => invoke($0, `gt_s`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:383
+assert_return(() => invoke($0, `gt_s`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:384
+assert_return(() => invoke($0, `gt_s`, [-1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:385
+assert_return(() => invoke($0, `gt_s`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:386
+assert_return(() => invoke($0, `gt_s`, [2147483647, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:387
+assert_return(() => invoke($0, `gt_s`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:388
+assert_return(() => invoke($0, `gt_s`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:389
+assert_return(() => invoke($0, `gt_s`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:390
+assert_return(() => invoke($0, `gt_s`, [-2147483648, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:391
+assert_return(() => invoke($0, `gt_s`, [0, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:392
+assert_return(() => invoke($0, `gt_s`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:393
+assert_return(() => invoke($0, `gt_s`, [-1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:394
+assert_return(() => invoke($0, `gt_s`, [-2147483648, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:395
+assert_return(() => invoke($0, `gt_s`, [2147483647, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:397
+assert_return(() => invoke($0, `gt_u`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:398
+assert_return(() => invoke($0, `gt_u`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:399
+assert_return(() => invoke($0, `gt_u`, [-1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:400
+assert_return(() => invoke($0, `gt_u`, [-2147483648, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:401
+assert_return(() => invoke($0, `gt_u`, [2147483647, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:402
+assert_return(() => invoke($0, `gt_u`, [-1, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:403
+assert_return(() => invoke($0, `gt_u`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:404
+assert_return(() => invoke($0, `gt_u`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:405
+assert_return(() => invoke($0, `gt_u`, [-2147483648, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:406
+assert_return(() => invoke($0, `gt_u`, [0, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:407
+assert_return(() => invoke($0, `gt_u`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:408
+assert_return(() => invoke($0, `gt_u`, [-1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:409
+assert_return(() => invoke($0, `gt_u`, [-2147483648, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:410
+assert_return(() => invoke($0, `gt_u`, [2147483647, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:412
+assert_return(() => invoke($0, `ge_s`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:413
+assert_return(() => invoke($0, `ge_s`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:414
+assert_return(() => invoke($0, `ge_s`, [-1, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:415
+assert_return(() => invoke($0, `ge_s`, [-2147483648, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:416
+assert_return(() => invoke($0, `ge_s`, [2147483647, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:417
+assert_return(() => invoke($0, `ge_s`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:418
+assert_return(() => invoke($0, `ge_s`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:419
+assert_return(() => invoke($0, `ge_s`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:420
+assert_return(() => invoke($0, `ge_s`, [-2147483648, 0]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:421
+assert_return(() => invoke($0, `ge_s`, [0, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:422
+assert_return(() => invoke($0, `ge_s`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:423
+assert_return(() => invoke($0, `ge_s`, [-1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:424
+assert_return(() => invoke($0, `ge_s`, [-2147483648, 2147483647]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:425
+assert_return(() => invoke($0, `ge_s`, [2147483647, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:427
+assert_return(() => invoke($0, `ge_u`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:428
+assert_return(() => invoke($0, `ge_u`, [1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:429
+assert_return(() => invoke($0, `ge_u`, [-1, 1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:430
+assert_return(() => invoke($0, `ge_u`, [-2147483648, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:431
+assert_return(() => invoke($0, `ge_u`, [2147483647, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:432
+assert_return(() => invoke($0, `ge_u`, [-1, -1]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:433
+assert_return(() => invoke($0, `ge_u`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:434
+assert_return(() => invoke($0, `ge_u`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:435
+assert_return(() => invoke($0, `ge_u`, [-2147483648, 0]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:436
+assert_return(() => invoke($0, `ge_u`, [0, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:437
+assert_return(() => invoke($0, `ge_u`, [-2147483648, -1]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:438
+assert_return(() => invoke($0, `ge_u`, [-1, -2147483648]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:439
+assert_return(() => invoke($0, `ge_u`, [-2147483648, 2147483647]), [value("i32", 1)]);
+
+// ./test/core/i32.wast:440
+assert_return(() => invoke($0, `ge_u`, [2147483647, -2147483648]), [value("i32", 0)]);
+
+// ./test/core/i32.wast:443
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty
+      (i32.eqz) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:451
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.eqz) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:460
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.eqz) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:469
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-if
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.eqz) (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:478
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:487
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.eqz)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:496
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.eqz) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:505
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.eqz)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:514
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-return
+      (return (i32.eqz)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:522
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-select
+      (select (i32.eqz) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:530
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-call
+      (call 1 (i32.eqz)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:539
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-unary-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.eqz) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:555
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.eqz)) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:564
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-unary-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.eqz)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:573
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-unary-operand-empty-in-global.set
+      (global.set $$x (i32.eqz)) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:582
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-unary-operand-empty-in-memory.grow
+      (memory.grow (i32.eqz)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:591
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-unary-operand-empty-in-load
+      (i32.load (i32.eqz)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:600
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-unary-operand-empty-in-store
+      (i32.store (i32.eqz) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:610
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty
+      (i32.add) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:618
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty
+      (i32.const 0) (i32.add) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:626
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.add) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:635
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.add) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:644
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.add) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:653
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.add) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:662
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-if
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (i32.add) (then (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:671
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-if
+      (i32.const 0) (i32.const 0)
+      (if (i32.const 0) (then (i32.add)) (else (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:680
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-else
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0)))
+      (drop) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:690
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.add)))
+      (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:700
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-br
+      (i32.const 0) (i32.const 0)
+      (block (br 0 (i32.add)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:709
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.const 0) (i32.add)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:718
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-br_if
+      (i32.const 0) (i32.const 0)
+      (block (br_if 0 (i32.add) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:727
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.const 0) (i32.add) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:736
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-br_table
+      (i32.const 0) (i32.const 0)
+      (block (br_table 0 (i32.add)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:745
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.const 0) (i32.add)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:754
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-return
+      (return (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:762
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-return
+      (return (i32.const 0) (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:770
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-select
+      (select (i32.add) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:778
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-select
+      (select (i32.const 0) (i32.add) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:786
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-call
+      (call 1 (i32.add)) (drop)
+    )
+    (func (param i32 i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:795
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-call
+      (call 1 (i32.const 0) (i32.add)) (drop)
+    )
+    (func (param i32 i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:804
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-binary-1st-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.add) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:820
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-binary-2nd-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.const 0) (i32.add) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:836
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.add)) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:845
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.const 0) (i32.add)) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:854
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-1st-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:863
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-binary-2nd-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.const 0) (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:872
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-binary-1st-operand-empty-in-global.set
+      (global.set $$x (i32.add)) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:881
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-binary-2nd-operand-empty-in-global.set
+      (global.set $$x (i32.const 0) (i32.add)) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:890
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-binary-1st-operand-empty-in-memory.grow
+      (memory.grow (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:899
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-binary-2nd-operand-empty-in-memory.grow
+      (memory.grow (i32.const 0) (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:908
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-binary-1st-operand-empty-in-load
+      (i32.load (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:917
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-binary-2nd-operand-empty-in-load
+      (i32.load (i32.const 0) (i32.add)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:926
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-binary-1st-operand-empty-in-store
+      (i32.store (i32.add) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:935
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-binary-2nd-operand-empty-in-store
+      (i32.store (i32.const 1) (i32.add) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:948
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.add (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:949
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.and (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:950
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.div_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:951
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.div_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:952
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.mul (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:953
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.or (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:954
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.rem_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:955
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.rem_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:956
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.rotl (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:957
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.rotr (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:958
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.shl (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:959
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.shr_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:960
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.shr_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:961
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.sub (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:962
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.xor (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:963
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.eqz (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:964
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.clz (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:965
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.ctz (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:966
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.popcnt (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:967
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.eq (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:968
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.ge_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:969
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.ge_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:970
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.gt_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:971
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.gt_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:972
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.le_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:973
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.le_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:974
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:975
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:976
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32.ne (i64.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i32.wast:978
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32.const nan:arithmetic)) `),
+  `unexpected token`,
+);
+
+// ./test/core/i32.wast:982
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32.const nan:canonical)) `),
+  `unexpected token`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/i64.wast.js b/js/src/jit-test/tests/wasm/spec/spec/i64.wast.js
new file mode 100644
index 0000000000..1fb9bc1cc8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/i64.wast.js
@@ -0,0 +1,1600 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/i64.wast
+
+// ./test/core/i64.wast:3
+let $0 = instantiate(`(module
+  (func (export "add") (param $$x i64) (param $$y i64) (result i64) (i64.add (local.get $$x) (local.get $$y)))
+  (func (export "sub") (param $$x i64) (param $$y i64) (result i64) (i64.sub (local.get $$x) (local.get $$y)))
+  (func (export "mul") (param $$x i64) (param $$y i64) (result i64) (i64.mul (local.get $$x) (local.get $$y)))
+  (func (export "div_s") (param $$x i64) (param $$y i64) (result i64) (i64.div_s (local.get $$x) (local.get $$y)))
+  (func (export "div_u") (param $$x i64) (param $$y i64) (result i64) (i64.div_u (local.get $$x) (local.get $$y)))
+  (func (export "rem_s") (param $$x i64) (param $$y i64) (result i64) (i64.rem_s (local.get $$x) (local.get $$y)))
+  (func (export "rem_u") (param $$x i64) (param $$y i64) (result i64) (i64.rem_u (local.get $$x) (local.get $$y)))
+  (func (export "and") (param $$x i64) (param $$y i64) (result i64) (i64.and (local.get $$x) (local.get $$y)))
+  (func (export "or") (param $$x i64) (param $$y i64) (result i64) (i64.or (local.get $$x) (local.get $$y)))
+  (func (export "xor") (param $$x i64) (param $$y i64) (result i64) (i64.xor (local.get $$x) (local.get $$y)))
+  (func (export "shl") (param $$x i64) (param $$y i64) (result i64) (i64.shl (local.get $$x) (local.get $$y)))
+  (func (export "shr_s") (param $$x i64) (param $$y i64) (result i64) (i64.shr_s (local.get $$x) (local.get $$y)))
+  (func (export "shr_u") (param $$x i64) (param $$y i64) (result i64) (i64.shr_u (local.get $$x) (local.get $$y)))
+  (func (export "rotl") (param $$x i64) (param $$y i64) (result i64) (i64.rotl (local.get $$x) (local.get $$y)))
+  (func (export "rotr") (param $$x i64) (param $$y i64) (result i64) (i64.rotr (local.get $$x) (local.get $$y)))
+  (func (export "clz") (param $$x i64) (result i64) (i64.clz (local.get $$x)))
+  (func (export "ctz") (param $$x i64) (result i64) (i64.ctz (local.get $$x)))
+  (func (export "popcnt") (param $$x i64) (result i64) (i64.popcnt (local.get $$x)))
+  (func (export "extend8_s") (param $$x i64) (result i64) (i64.extend8_s (local.get $$x)))
+  (func (export "extend16_s") (param $$x i64) (result i64) (i64.extend16_s (local.get $$x)))
+  (func (export "extend32_s") (param $$x i64) (result i64) (i64.extend32_s (local.get $$x)))
+  (func (export "eqz") (param $$x i64) (result i32) (i64.eqz (local.get $$x)))
+  (func (export "eq") (param $$x i64) (param $$y i64) (result i32) (i64.eq (local.get $$x) (local.get $$y)))
+  (func (export "ne") (param $$x i64) (param $$y i64) (result i32) (i64.ne (local.get $$x) (local.get $$y)))
+  (func (export "lt_s") (param $$x i64) (param $$y i64) (result i32) (i64.lt_s (local.get $$x) (local.get $$y)))
+  (func (export "lt_u") (param $$x i64) (param $$y i64) (result i32) (i64.lt_u (local.get $$x) (local.get $$y)))
+  (func (export "le_s") (param $$x i64) (param $$y i64) (result i32) (i64.le_s (local.get $$x) (local.get $$y)))
+  (func (export "le_u") (param $$x i64) (param $$y i64) (result i32) (i64.le_u (local.get $$x) (local.get $$y)))
+  (func (export "gt_s") (param $$x i64) (param $$y i64) (result i32) (i64.gt_s (local.get $$x) (local.get $$y)))
+  (func (export "gt_u") (param $$x i64) (param $$y i64) (result i32) (i64.gt_u (local.get $$x) (local.get $$y)))
+  (func (export "ge_s") (param $$x i64) (param $$y i64) (result i32) (i64.ge_s (local.get $$x) (local.get $$y)))
+  (func (export "ge_u") (param $$x i64) (param $$y i64) (result i32) (i64.ge_u (local.get $$x) (local.get $$y)))
+)`);
+
+// ./test/core/i64.wast:38
+assert_return(() => invoke($0, `add`, [1n, 1n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:39
+assert_return(() => invoke($0, `add`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:40
+assert_return(() => invoke($0, `add`, [-1n, -1n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:41
+assert_return(() => invoke($0, `add`, [-1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:42
+assert_return(
+  () => invoke($0, `add`, [9223372036854775807n, 1n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:43
+assert_return(
+  () => invoke($0, `add`, [-9223372036854775808n, -1n]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/i64.wast:44
+assert_return(
+  () => invoke($0, `add`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/i64.wast:45
+assert_return(() => invoke($0, `add`, [1073741823n, 1n]), [value("i64", 1073741824n)]);
+
+// ./test/core/i64.wast:47
+assert_return(() => invoke($0, `sub`, [1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:48
+assert_return(() => invoke($0, `sub`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:49
+assert_return(() => invoke($0, `sub`, [-1n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:50
+assert_return(
+  () => invoke($0, `sub`, [9223372036854775807n, -1n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:51
+assert_return(
+  () => invoke($0, `sub`, [-9223372036854775808n, 1n]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/i64.wast:52
+assert_return(
+  () => invoke($0, `sub`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/i64.wast:53
+assert_return(() => invoke($0, `sub`, [1073741823n, -1n]), [value("i64", 1073741824n)]);
+
+// ./test/core/i64.wast:55
+assert_return(() => invoke($0, `mul`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:56
+assert_return(() => invoke($0, `mul`, [1n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:57
+assert_return(() => invoke($0, `mul`, [-1n, -1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:58
+assert_return(() => invoke($0, `mul`, [1152921504606846976n, 4096n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:59
+assert_return(() => invoke($0, `mul`, [-9223372036854775808n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:60
+assert_return(
+  () => invoke($0, `mul`, [-9223372036854775808n, -1n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:61
+assert_return(
+  () => invoke($0, `mul`, [9223372036854775807n, -1n]),
+  [value("i64", -9223372036854775807n)],
+);
+
+// ./test/core/i64.wast:62
+assert_return(
+  () => invoke($0, `mul`, [81985529216486895n, -81985529216486896n]),
+  [value("i64", 2465395958572223728n)],
+);
+
+// ./test/core/i64.wast:63
+assert_return(() => invoke($0, `mul`, [9223372036854775807n, 9223372036854775807n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:65
+assert_trap(() => invoke($0, `div_s`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:66
+assert_trap(() => invoke($0, `div_s`, [0n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:67
+assert_trap(() => invoke($0, `div_s`, [-9223372036854775808n, -1n]), `integer overflow`);
+
+// ./test/core/i64.wast:68
+assert_trap(() => invoke($0, `div_s`, [-9223372036854775808n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:69
+assert_return(() => invoke($0, `div_s`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:70
+assert_return(() => invoke($0, `div_s`, [0n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:71
+assert_return(() => invoke($0, `div_s`, [0n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:72
+assert_return(() => invoke($0, `div_s`, [-1n, -1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:73
+assert_return(
+  () => invoke($0, `div_s`, [-9223372036854775808n, 2n]),
+  [value("i64", -4611686018427387904n)],
+);
+
+// ./test/core/i64.wast:74
+assert_return(
+  () => invoke($0, `div_s`, [-9223372036854775807n, 1000n]),
+  [value("i64", -9223372036854775n)],
+);
+
+// ./test/core/i64.wast:75
+assert_return(() => invoke($0, `div_s`, [5n, 2n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:76
+assert_return(() => invoke($0, `div_s`, [-5n, 2n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:77
+assert_return(() => invoke($0, `div_s`, [5n, -2n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:78
+assert_return(() => invoke($0, `div_s`, [-5n, -2n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:79
+assert_return(() => invoke($0, `div_s`, [7n, 3n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:80
+assert_return(() => invoke($0, `div_s`, [-7n, 3n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:81
+assert_return(() => invoke($0, `div_s`, [7n, -3n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:82
+assert_return(() => invoke($0, `div_s`, [-7n, -3n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:83
+assert_return(() => invoke($0, `div_s`, [11n, 5n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:84
+assert_return(() => invoke($0, `div_s`, [17n, 7n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:86
+assert_trap(() => invoke($0, `div_u`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:87
+assert_trap(() => invoke($0, `div_u`, [0n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:88
+assert_return(() => invoke($0, `div_u`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:89
+assert_return(() => invoke($0, `div_u`, [0n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:90
+assert_return(() => invoke($0, `div_u`, [-1n, -1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:91
+assert_return(() => invoke($0, `div_u`, [-9223372036854775808n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:92
+assert_return(
+  () => invoke($0, `div_u`, [-9223372036854775808n, 2n]),
+  [value("i64", 4611686018427387904n)],
+);
+
+// ./test/core/i64.wast:93
+assert_return(
+  () => invoke($0, `div_u`, [-8074936608141340688n, 4294967297n]),
+  [value("i64", 2414874607n)],
+);
+
+// ./test/core/i64.wast:94
+assert_return(
+  () => invoke($0, `div_u`, [-9223372036854775807n, 1000n]),
+  [value("i64", 9223372036854775n)],
+);
+
+// ./test/core/i64.wast:95
+assert_return(() => invoke($0, `div_u`, [5n, 2n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:96
+assert_return(() => invoke($0, `div_u`, [-5n, 2n]), [value("i64", 9223372036854775805n)]);
+
+// ./test/core/i64.wast:97
+assert_return(() => invoke($0, `div_u`, [5n, -2n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:98
+assert_return(() => invoke($0, `div_u`, [-5n, -2n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:99
+assert_return(() => invoke($0, `div_u`, [7n, 3n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:100
+assert_return(() => invoke($0, `div_u`, [11n, 5n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:101
+assert_return(() => invoke($0, `div_u`, [17n, 7n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:103
+assert_trap(() => invoke($0, `rem_s`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:104
+assert_trap(() => invoke($0, `rem_s`, [0n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:105
+assert_return(() => invoke($0, `rem_s`, [9223372036854775807n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:106
+assert_return(() => invoke($0, `rem_s`, [1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:107
+assert_return(() => invoke($0, `rem_s`, [0n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:108
+assert_return(() => invoke($0, `rem_s`, [0n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:109
+assert_return(() => invoke($0, `rem_s`, [-1n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:110
+assert_return(() => invoke($0, `rem_s`, [-9223372036854775808n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:111
+assert_return(() => invoke($0, `rem_s`, [-9223372036854775808n, 2n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:112
+assert_return(() => invoke($0, `rem_s`, [-9223372036854775807n, 1000n]), [value("i64", -807n)]);
+
+// ./test/core/i64.wast:113
+assert_return(() => invoke($0, `rem_s`, [5n, 2n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:114
+assert_return(() => invoke($0, `rem_s`, [-5n, 2n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:115
+assert_return(() => invoke($0, `rem_s`, [5n, -2n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:116
+assert_return(() => invoke($0, `rem_s`, [-5n, -2n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:117
+assert_return(() => invoke($0, `rem_s`, [7n, 3n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:118
+assert_return(() => invoke($0, `rem_s`, [-7n, 3n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:119
+assert_return(() => invoke($0, `rem_s`, [7n, -3n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:120
+assert_return(() => invoke($0, `rem_s`, [-7n, -3n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:121
+assert_return(() => invoke($0, `rem_s`, [11n, 5n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:122
+assert_return(() => invoke($0, `rem_s`, [17n, 7n]), [value("i64", 3n)]);
+
+// ./test/core/i64.wast:124
+assert_trap(() => invoke($0, `rem_u`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:125
+assert_trap(() => invoke($0, `rem_u`, [0n, 0n]), `integer divide by zero`);
+
+// ./test/core/i64.wast:126
+assert_return(() => invoke($0, `rem_u`, [1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:127
+assert_return(() => invoke($0, `rem_u`, [0n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:128
+assert_return(() => invoke($0, `rem_u`, [-1n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:129
+assert_return(
+  () => invoke($0, `rem_u`, [-9223372036854775808n, -1n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:130
+assert_return(() => invoke($0, `rem_u`, [-9223372036854775808n, 2n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:131
+assert_return(
+  () => invoke($0, `rem_u`, [-8074936608141340688n, 4294967297n]),
+  [value("i64", 2147483649n)],
+);
+
+// ./test/core/i64.wast:132
+assert_return(() => invoke($0, `rem_u`, [-9223372036854775807n, 1000n]), [value("i64", 809n)]);
+
+// ./test/core/i64.wast:133
+assert_return(() => invoke($0, `rem_u`, [5n, 2n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:134
+assert_return(() => invoke($0, `rem_u`, [-5n, 2n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:135
+assert_return(() => invoke($0, `rem_u`, [5n, -2n]), [value("i64", 5n)]);
+
+// ./test/core/i64.wast:136
+assert_return(() => invoke($0, `rem_u`, [-5n, -2n]), [value("i64", -5n)]);
+
+// ./test/core/i64.wast:137
+assert_return(() => invoke($0, `rem_u`, [7n, 3n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:138
+assert_return(() => invoke($0, `rem_u`, [11n, 5n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:139
+assert_return(() => invoke($0, `rem_u`, [17n, 7n]), [value("i64", 3n)]);
+
+// ./test/core/i64.wast:141
+assert_return(() => invoke($0, `and`, [1n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:142
+assert_return(() => invoke($0, `and`, [0n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:143
+assert_return(() => invoke($0, `and`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:144
+assert_return(() => invoke($0, `and`, [0n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:145
+assert_return(
+  () => invoke($0, `and`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/i64.wast:146
+assert_return(
+  () => invoke($0, `and`, [9223372036854775807n, -1n]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/i64.wast:147
+assert_return(() => invoke($0, `and`, [4042326015n, 4294963440n]), [value("i64", 4042322160n)]);
+
+// ./test/core/i64.wast:148
+assert_return(() => invoke($0, `and`, [-1n, -1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:150
+assert_return(() => invoke($0, `or`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:151
+assert_return(() => invoke($0, `or`, [0n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:152
+assert_return(() => invoke($0, `or`, [1n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:153
+assert_return(() => invoke($0, `or`, [0n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:154
+assert_return(
+  () => invoke($0, `or`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/i64.wast:155
+assert_return(
+  () => invoke($0, `or`, [-9223372036854775808n, 0n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:156
+assert_return(() => invoke($0, `or`, [4042326015n, 4294963440n]), [value("i64", 4294967295n)]);
+
+// ./test/core/i64.wast:157
+assert_return(() => invoke($0, `or`, [-1n, -1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:159
+assert_return(() => invoke($0, `xor`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:160
+assert_return(() => invoke($0, `xor`, [0n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:161
+assert_return(() => invoke($0, `xor`, [1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:162
+assert_return(() => invoke($0, `xor`, [0n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:163
+assert_return(
+  () => invoke($0, `xor`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/i64.wast:164
+assert_return(
+  () => invoke($0, `xor`, [-9223372036854775808n, 0n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:165
+assert_return(
+  () => invoke($0, `xor`, [-1n, -9223372036854775808n]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/i64.wast:166
+assert_return(
+  () => invoke($0, `xor`, [-1n, 9223372036854775807n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:167
+assert_return(() => invoke($0, `xor`, [4042326015n, 4294963440n]), [value("i64", 252645135n)]);
+
+// ./test/core/i64.wast:168
+assert_return(() => invoke($0, `xor`, [-1n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:170
+assert_return(() => invoke($0, `shl`, [1n, 1n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:171
+assert_return(() => invoke($0, `shl`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:172
+assert_return(() => invoke($0, `shl`, [9223372036854775807n, 1n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:173
+assert_return(() => invoke($0, `shl`, [-1n, 1n]), [value("i64", -2n)]);
+
+// ./test/core/i64.wast:174
+assert_return(() => invoke($0, `shl`, [-9223372036854775808n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:175
+assert_return(
+  () => invoke($0, `shl`, [4611686018427387904n, 1n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:176
+assert_return(() => invoke($0, `shl`, [1n, 63n]), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/i64.wast:177
+assert_return(() => invoke($0, `shl`, [1n, 64n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:178
+assert_return(() => invoke($0, `shl`, [1n, 65n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:179
+assert_return(() => invoke($0, `shl`, [1n, -1n]), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/i64.wast:180
+assert_return(
+  () => invoke($0, `shl`, [1n, 9223372036854775807n]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/i64.wast:182
+assert_return(() => invoke($0, `shr_s`, [1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:183
+assert_return(() => invoke($0, `shr_s`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:184
+assert_return(() => invoke($0, `shr_s`, [-1n, 1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:185
+assert_return(
+  () => invoke($0, `shr_s`, [9223372036854775807n, 1n]),
+  [value("i64", 4611686018427387903n)],
+);
+
+// ./test/core/i64.wast:186
+assert_return(
+  () => invoke($0, `shr_s`, [-9223372036854775808n, 1n]),
+  [value("i64", -4611686018427387904n)],
+);
+
+// ./test/core/i64.wast:187
+assert_return(
+  () => invoke($0, `shr_s`, [4611686018427387904n, 1n]),
+  [value("i64", 2305843009213693952n)],
+);
+
+// ./test/core/i64.wast:188
+assert_return(() => invoke($0, `shr_s`, [1n, 64n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:189
+assert_return(() => invoke($0, `shr_s`, [1n, 65n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:190
+assert_return(() => invoke($0, `shr_s`, [1n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:191
+assert_return(() => invoke($0, `shr_s`, [1n, 9223372036854775807n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:192
+assert_return(() => invoke($0, `shr_s`, [1n, -9223372036854775808n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:193
+assert_return(() => invoke($0, `shr_s`, [-9223372036854775808n, 63n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:194
+assert_return(() => invoke($0, `shr_s`, [-1n, 64n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:195
+assert_return(() => invoke($0, `shr_s`, [-1n, 65n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:196
+assert_return(() => invoke($0, `shr_s`, [-1n, -1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:197
+assert_return(() => invoke($0, `shr_s`, [-1n, 9223372036854775807n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:198
+assert_return(() => invoke($0, `shr_s`, [-1n, -9223372036854775808n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:200
+assert_return(() => invoke($0, `shr_u`, [1n, 1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:201
+assert_return(() => invoke($0, `shr_u`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:202
+assert_return(() => invoke($0, `shr_u`, [-1n, 1n]), [value("i64", 9223372036854775807n)]);
+
+// ./test/core/i64.wast:203
+assert_return(
+  () => invoke($0, `shr_u`, [9223372036854775807n, 1n]),
+  [value("i64", 4611686018427387903n)],
+);
+
+// ./test/core/i64.wast:204
+assert_return(
+  () => invoke($0, `shr_u`, [-9223372036854775808n, 1n]),
+  [value("i64", 4611686018427387904n)],
+);
+
+// ./test/core/i64.wast:205
+assert_return(
+  () => invoke($0, `shr_u`, [4611686018427387904n, 1n]),
+  [value("i64", 2305843009213693952n)],
+);
+
+// ./test/core/i64.wast:206
+assert_return(() => invoke($0, `shr_u`, [1n, 64n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:207
+assert_return(() => invoke($0, `shr_u`, [1n, 65n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:208
+assert_return(() => invoke($0, `shr_u`, [1n, -1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:209
+assert_return(() => invoke($0, `shr_u`, [1n, 9223372036854775807n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:210
+assert_return(() => invoke($0, `shr_u`, [1n, -9223372036854775808n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:211
+assert_return(() => invoke($0, `shr_u`, [-9223372036854775808n, 63n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:212
+assert_return(() => invoke($0, `shr_u`, [-1n, 64n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:213
+assert_return(() => invoke($0, `shr_u`, [-1n, 65n]), [value("i64", 9223372036854775807n)]);
+
+// ./test/core/i64.wast:214
+assert_return(() => invoke($0, `shr_u`, [-1n, -1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:215
+assert_return(() => invoke($0, `shr_u`, [-1n, 9223372036854775807n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:216
+assert_return(() => invoke($0, `shr_u`, [-1n, -9223372036854775808n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:218
+assert_return(() => invoke($0, `rotl`, [1n, 1n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:219
+assert_return(() => invoke($0, `rotl`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:220
+assert_return(() => invoke($0, `rotl`, [-1n, 1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:221
+assert_return(() => invoke($0, `rotl`, [1n, 64n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:222
+assert_return(
+  () => invoke($0, `rotl`, [-6067025490386449714n, 1n]),
+  [value("i64", 6312693092936652189n)],
+);
+
+// ./test/core/i64.wast:223
+assert_return(
+  () => invoke($0, `rotl`, [-144115184384868352n, 4n]),
+  [value("i64", -2305842950157893617n)],
+);
+
+// ./test/core/i64.wast:224
+assert_return(
+  () => invoke($0, `rotl`, [-6067173104435169271n, 53n]),
+  [value("i64", 87109505680009935n)],
+);
+
+// ./test/core/i64.wast:225
+assert_return(
+  () => invoke($0, `rotl`, [-6066028401059725156n, 63n]),
+  [value("i64", 6190357836324913230n)],
+);
+
+// ./test/core/i64.wast:226
+assert_return(
+  () => invoke($0, `rotl`, [-6067173104435169271n, 245n]),
+  [value("i64", 87109505680009935n)],
+);
+
+// ./test/core/i64.wast:227
+assert_return(
+  () => invoke($0, `rotl`, [-6067067139002042359n, -19n]),
+  [value("i64", -3530481836149793302n)],
+);
+
+// ./test/core/i64.wast:228
+assert_return(
+  () => invoke($0, `rotl`, [-6066028401059725156n, -9223372036854775745n]),
+  [value("i64", 6190357836324913230n)],
+);
+
+// ./test/core/i64.wast:229
+assert_return(() => invoke($0, `rotl`, [1n, 63n]), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/i64.wast:230
+assert_return(() => invoke($0, `rotl`, [-9223372036854775808n, 1n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:232
+assert_return(() => invoke($0, `rotr`, [1n, 1n]), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/i64.wast:233
+assert_return(() => invoke($0, `rotr`, [1n, 0n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:234
+assert_return(() => invoke($0, `rotr`, [-1n, 1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:235
+assert_return(() => invoke($0, `rotr`, [1n, 64n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:236
+assert_return(
+  () => invoke($0, `rotr`, [-6067025490386449714n, 1n]),
+  [value("i64", 6189859291661550951n)],
+);
+
+// ./test/core/i64.wast:237
+assert_return(
+  () => invoke($0, `rotr`, [-144115184384868352n, 4n]),
+  [value("i64", 1143914305582792704n)],
+);
+
+// ./test/core/i64.wast:238
+assert_return(
+  () => invoke($0, `rotr`, [-6067173104435169271n, 53n]),
+  [value("i64", 7534987797011123550n)],
+);
+
+// ./test/core/i64.wast:239
+assert_return(
+  () => invoke($0, `rotr`, [-6066028401059725156n, 63n]),
+  [value("i64", 6314687271590101305n)],
+);
+
+// ./test/core/i64.wast:240
+assert_return(
+  () => invoke($0, `rotr`, [-6067173104435169271n, 245n]),
+  [value("i64", 7534987797011123550n)],
+);
+
+// ./test/core/i64.wast:241
+assert_return(
+  () => invoke($0, `rotr`, [-6067067139002042359n, -19n]),
+  [value("i64", -7735078922541506965n)],
+);
+
+// ./test/core/i64.wast:242
+assert_return(
+  () => invoke($0, `rotr`, [-6066028401059725156n, -9223372036854775745n]),
+  [value("i64", 6314687271590101305n)],
+);
+
+// ./test/core/i64.wast:243
+assert_return(() => invoke($0, `rotr`, [1n, 63n]), [value("i64", 2n)]);
+
+// ./test/core/i64.wast:244
+assert_return(() => invoke($0, `rotr`, [-9223372036854775808n, 63n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:246
+assert_return(() => invoke($0, `clz`, [-1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:247
+assert_return(() => invoke($0, `clz`, [0n]), [value("i64", 64n)]);
+
+// ./test/core/i64.wast:248
+assert_return(() => invoke($0, `clz`, [32768n]), [value("i64", 48n)]);
+
+// ./test/core/i64.wast:249
+assert_return(() => invoke($0, `clz`, [255n]), [value("i64", 56n)]);
+
+// ./test/core/i64.wast:250
+assert_return(() => invoke($0, `clz`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:251
+assert_return(() => invoke($0, `clz`, [1n]), [value("i64", 63n)]);
+
+// ./test/core/i64.wast:252
+assert_return(() => invoke($0, `clz`, [2n]), [value("i64", 62n)]);
+
+// ./test/core/i64.wast:253
+assert_return(() => invoke($0, `clz`, [9223372036854775807n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:255
+assert_return(() => invoke($0, `ctz`, [-1n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:256
+assert_return(() => invoke($0, `ctz`, [0n]), [value("i64", 64n)]);
+
+// ./test/core/i64.wast:257
+assert_return(() => invoke($0, `ctz`, [32768n]), [value("i64", 15n)]);
+
+// ./test/core/i64.wast:258
+assert_return(() => invoke($0, `ctz`, [65536n]), [value("i64", 16n)]);
+
+// ./test/core/i64.wast:259
+assert_return(() => invoke($0, `ctz`, [-9223372036854775808n]), [value("i64", 63n)]);
+
+// ./test/core/i64.wast:260
+assert_return(() => invoke($0, `ctz`, [9223372036854775807n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:262
+assert_return(() => invoke($0, `popcnt`, [-1n]), [value("i64", 64n)]);
+
+// ./test/core/i64.wast:263
+assert_return(() => invoke($0, `popcnt`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:264
+assert_return(() => invoke($0, `popcnt`, [32768n]), [value("i64", 1n)]);
+
+// ./test/core/i64.wast:265
+assert_return(() => invoke($0, `popcnt`, [-9223231297218904064n]), [value("i64", 4n)]);
+
+// ./test/core/i64.wast:266
+assert_return(() => invoke($0, `popcnt`, [9223372036854775807n]), [value("i64", 63n)]);
+
+// ./test/core/i64.wast:267
+assert_return(() => invoke($0, `popcnt`, [-6148914692668172971n]), [value("i64", 32n)]);
+
+// ./test/core/i64.wast:268
+assert_return(() => invoke($0, `popcnt`, [-7378697629197489494n]), [value("i64", 32n)]);
+
+// ./test/core/i64.wast:269
+assert_return(() => invoke($0, `popcnt`, [-2401053088876216593n]), [value("i64", 48n)]);
+
+// ./test/core/i64.wast:271
+assert_return(() => invoke($0, `extend8_s`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:272
+assert_return(() => invoke($0, `extend8_s`, [127n]), [value("i64", 127n)]);
+
+// ./test/core/i64.wast:273
+assert_return(() => invoke($0, `extend8_s`, [128n]), [value("i64", -128n)]);
+
+// ./test/core/i64.wast:274
+assert_return(() => invoke($0, `extend8_s`, [255n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:275
+assert_return(() => invoke($0, `extend8_s`, [81985529216486656n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:276
+assert_return(() => invoke($0, `extend8_s`, [-81985529216486784n]), [value("i64", -128n)]);
+
+// ./test/core/i64.wast:277
+assert_return(() => invoke($0, `extend8_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:279
+assert_return(() => invoke($0, `extend16_s`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:280
+assert_return(() => invoke($0, `extend16_s`, [32767n]), [value("i64", 32767n)]);
+
+// ./test/core/i64.wast:281
+assert_return(() => invoke($0, `extend16_s`, [32768n]), [value("i64", -32768n)]);
+
+// ./test/core/i64.wast:282
+assert_return(() => invoke($0, `extend16_s`, [65535n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:283
+assert_return(() => invoke($0, `extend16_s`, [1311768467463733248n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:284
+assert_return(() => invoke($0, `extend16_s`, [-81985529216466944n]), [value("i64", -32768n)]);
+
+// ./test/core/i64.wast:285
+assert_return(() => invoke($0, `extend16_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:287
+assert_return(() => invoke($0, `extend32_s`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:288
+assert_return(() => invoke($0, `extend32_s`, [32767n]), [value("i64", 32767n)]);
+
+// ./test/core/i64.wast:289
+assert_return(() => invoke($0, `extend32_s`, [32768n]), [value("i64", 32768n)]);
+
+// ./test/core/i64.wast:290
+assert_return(() => invoke($0, `extend32_s`, [65535n]), [value("i64", 65535n)]);
+
+// ./test/core/i64.wast:291
+assert_return(() => invoke($0, `extend32_s`, [2147483647n]), [value("i64", 2147483647n)]);
+
+// ./test/core/i64.wast:292
+assert_return(() => invoke($0, `extend32_s`, [2147483648n]), [value("i64", -2147483648n)]);
+
+// ./test/core/i64.wast:293
+assert_return(() => invoke($0, `extend32_s`, [4294967295n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:294
+assert_return(() => invoke($0, `extend32_s`, [81985526906748928n]), [value("i64", 0n)]);
+
+// ./test/core/i64.wast:295
+assert_return(() => invoke($0, `extend32_s`, [-81985529054232576n]), [value("i64", -2147483648n)]);
+
+// ./test/core/i64.wast:296
+assert_return(() => invoke($0, `extend32_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/i64.wast:298
+assert_return(() => invoke($0, `eqz`, [0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:299
+assert_return(() => invoke($0, `eqz`, [1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:300
+assert_return(() => invoke($0, `eqz`, [-9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:301
+assert_return(() => invoke($0, `eqz`, [9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:302
+assert_return(() => invoke($0, `eqz`, [-1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:304
+assert_return(() => invoke($0, `eq`, [0n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:305
+assert_return(() => invoke($0, `eq`, [1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:306
+assert_return(() => invoke($0, `eq`, [-1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:307
+assert_return(() => invoke($0, `eq`, [-9223372036854775808n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:308
+assert_return(() => invoke($0, `eq`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:309
+assert_return(() => invoke($0, `eq`, [-1n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:310
+assert_return(() => invoke($0, `eq`, [1n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:311
+assert_return(() => invoke($0, `eq`, [0n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:312
+assert_return(() => invoke($0, `eq`, [-9223372036854775808n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:313
+assert_return(() => invoke($0, `eq`, [0n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:314
+assert_return(() => invoke($0, `eq`, [-9223372036854775808n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:315
+assert_return(() => invoke($0, `eq`, [-1n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:316
+assert_return(() => invoke($0, `eq`, [-9223372036854775808n, 9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:317
+assert_return(() => invoke($0, `eq`, [9223372036854775807n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:319
+assert_return(() => invoke($0, `ne`, [0n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:320
+assert_return(() => invoke($0, `ne`, [1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:321
+assert_return(() => invoke($0, `ne`, [-1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:322
+assert_return(() => invoke($0, `ne`, [-9223372036854775808n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:323
+assert_return(() => invoke($0, `ne`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:324
+assert_return(() => invoke($0, `ne`, [-1n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:325
+assert_return(() => invoke($0, `ne`, [1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:326
+assert_return(() => invoke($0, `ne`, [0n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:327
+assert_return(() => invoke($0, `ne`, [-9223372036854775808n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:328
+assert_return(() => invoke($0, `ne`, [0n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:329
+assert_return(() => invoke($0, `ne`, [-9223372036854775808n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:330
+assert_return(() => invoke($0, `ne`, [-1n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:331
+assert_return(() => invoke($0, `ne`, [-9223372036854775808n, 9223372036854775807n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:332
+assert_return(() => invoke($0, `ne`, [9223372036854775807n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:334
+assert_return(() => invoke($0, `lt_s`, [0n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:335
+assert_return(() => invoke($0, `lt_s`, [1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:336
+assert_return(() => invoke($0, `lt_s`, [-1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:337
+assert_return(
+  () => invoke($0, `lt_s`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:338
+assert_return(() => invoke($0, `lt_s`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:339
+assert_return(() => invoke($0, `lt_s`, [-1n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:340
+assert_return(() => invoke($0, `lt_s`, [1n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:341
+assert_return(() => invoke($0, `lt_s`, [0n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:342
+assert_return(() => invoke($0, `lt_s`, [-9223372036854775808n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:343
+assert_return(() => invoke($0, `lt_s`, [0n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:344
+assert_return(() => invoke($0, `lt_s`, [-9223372036854775808n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:345
+assert_return(() => invoke($0, `lt_s`, [-1n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:346
+assert_return(
+  () => invoke($0, `lt_s`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:347
+assert_return(
+  () => invoke($0, `lt_s`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:349
+assert_return(() => invoke($0, `lt_u`, [0n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:350
+assert_return(() => invoke($0, `lt_u`, [1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:351
+assert_return(() => invoke($0, `lt_u`, [-1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:352
+assert_return(
+  () => invoke($0, `lt_u`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:353
+assert_return(() => invoke($0, `lt_u`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:354
+assert_return(() => invoke($0, `lt_u`, [-1n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:355
+assert_return(() => invoke($0, `lt_u`, [1n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:356
+assert_return(() => invoke($0, `lt_u`, [0n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:357
+assert_return(() => invoke($0, `lt_u`, [-9223372036854775808n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:358
+assert_return(() => invoke($0, `lt_u`, [0n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:359
+assert_return(() => invoke($0, `lt_u`, [-9223372036854775808n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:360
+assert_return(() => invoke($0, `lt_u`, [-1n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:361
+assert_return(
+  () => invoke($0, `lt_u`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:362
+assert_return(
+  () => invoke($0, `lt_u`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:364
+assert_return(() => invoke($0, `le_s`, [0n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:365
+assert_return(() => invoke($0, `le_s`, [1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:366
+assert_return(() => invoke($0, `le_s`, [-1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:367
+assert_return(
+  () => invoke($0, `le_s`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:368
+assert_return(() => invoke($0, `le_s`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:369
+assert_return(() => invoke($0, `le_s`, [-1n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:370
+assert_return(() => invoke($0, `le_s`, [1n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:371
+assert_return(() => invoke($0, `le_s`, [0n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:372
+assert_return(() => invoke($0, `le_s`, [-9223372036854775808n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:373
+assert_return(() => invoke($0, `le_s`, [0n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:374
+assert_return(() => invoke($0, `le_s`, [-9223372036854775808n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:375
+assert_return(() => invoke($0, `le_s`, [-1n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:376
+assert_return(
+  () => invoke($0, `le_s`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:377
+assert_return(
+  () => invoke($0, `le_s`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:379
+assert_return(() => invoke($0, `le_u`, [0n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:380
+assert_return(() => invoke($0, `le_u`, [1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:381
+assert_return(() => invoke($0, `le_u`, [-1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:382
+assert_return(
+  () => invoke($0, `le_u`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:383
+assert_return(() => invoke($0, `le_u`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:384
+assert_return(() => invoke($0, `le_u`, [-1n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:385
+assert_return(() => invoke($0, `le_u`, [1n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:386
+assert_return(() => invoke($0, `le_u`, [0n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:387
+assert_return(() => invoke($0, `le_u`, [-9223372036854775808n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:388
+assert_return(() => invoke($0, `le_u`, [0n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:389
+assert_return(() => invoke($0, `le_u`, [-9223372036854775808n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:390
+assert_return(() => invoke($0, `le_u`, [-1n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:391
+assert_return(
+  () => invoke($0, `le_u`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:392
+assert_return(
+  () => invoke($0, `le_u`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:394
+assert_return(() => invoke($0, `gt_s`, [0n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:395
+assert_return(() => invoke($0, `gt_s`, [1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:396
+assert_return(() => invoke($0, `gt_s`, [-1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:397
+assert_return(
+  () => invoke($0, `gt_s`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:398
+assert_return(() => invoke($0, `gt_s`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:399
+assert_return(() => invoke($0, `gt_s`, [-1n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:400
+assert_return(() => invoke($0, `gt_s`, [1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:401
+assert_return(() => invoke($0, `gt_s`, [0n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:402
+assert_return(() => invoke($0, `gt_s`, [-9223372036854775808n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:403
+assert_return(() => invoke($0, `gt_s`, [0n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:404
+assert_return(() => invoke($0, `gt_s`, [-9223372036854775808n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:405
+assert_return(() => invoke($0, `gt_s`, [-1n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:406
+assert_return(
+  () => invoke($0, `gt_s`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:407
+assert_return(
+  () => invoke($0, `gt_s`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:409
+assert_return(() => invoke($0, `gt_u`, [0n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:410
+assert_return(() => invoke($0, `gt_u`, [1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:411
+assert_return(() => invoke($0, `gt_u`, [-1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:412
+assert_return(
+  () => invoke($0, `gt_u`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:413
+assert_return(() => invoke($0, `gt_u`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:414
+assert_return(() => invoke($0, `gt_u`, [-1n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:415
+assert_return(() => invoke($0, `gt_u`, [1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:416
+assert_return(() => invoke($0, `gt_u`, [0n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:417
+assert_return(() => invoke($0, `gt_u`, [-9223372036854775808n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:418
+assert_return(() => invoke($0, `gt_u`, [0n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:419
+assert_return(() => invoke($0, `gt_u`, [-9223372036854775808n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:420
+assert_return(() => invoke($0, `gt_u`, [-1n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:421
+assert_return(
+  () => invoke($0, `gt_u`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:422
+assert_return(
+  () => invoke($0, `gt_u`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:424
+assert_return(() => invoke($0, `ge_s`, [0n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:425
+assert_return(() => invoke($0, `ge_s`, [1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:426
+assert_return(() => invoke($0, `ge_s`, [-1n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:427
+assert_return(
+  () => invoke($0, `ge_s`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:428
+assert_return(() => invoke($0, `ge_s`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:429
+assert_return(() => invoke($0, `ge_s`, [-1n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:430
+assert_return(() => invoke($0, `ge_s`, [1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:431
+assert_return(() => invoke($0, `ge_s`, [0n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:432
+assert_return(() => invoke($0, `ge_s`, [-9223372036854775808n, 0n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:433
+assert_return(() => invoke($0, `ge_s`, [0n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:434
+assert_return(() => invoke($0, `ge_s`, [-9223372036854775808n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:435
+assert_return(() => invoke($0, `ge_s`, [-1n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:436
+assert_return(
+  () => invoke($0, `ge_s`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:437
+assert_return(
+  () => invoke($0, `ge_s`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:439
+assert_return(() => invoke($0, `ge_u`, [0n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:440
+assert_return(() => invoke($0, `ge_u`, [1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:441
+assert_return(() => invoke($0, `ge_u`, [-1n, 1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:442
+assert_return(
+  () => invoke($0, `ge_u`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:443
+assert_return(() => invoke($0, `ge_u`, [9223372036854775807n, 9223372036854775807n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:444
+assert_return(() => invoke($0, `ge_u`, [-1n, -1n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:445
+assert_return(() => invoke($0, `ge_u`, [1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:446
+assert_return(() => invoke($0, `ge_u`, [0n, 1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:447
+assert_return(() => invoke($0, `ge_u`, [-9223372036854775808n, 0n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:448
+assert_return(() => invoke($0, `ge_u`, [0n, -9223372036854775808n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:449
+assert_return(() => invoke($0, `ge_u`, [-9223372036854775808n, -1n]), [value("i32", 0)]);
+
+// ./test/core/i64.wast:450
+assert_return(() => invoke($0, `ge_u`, [-1n, -9223372036854775808n]), [value("i32", 1)]);
+
+// ./test/core/i64.wast:451
+assert_return(
+  () => invoke($0, `ge_u`, [-9223372036854775808n, 9223372036854775807n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/i64.wast:452
+assert_return(
+  () => invoke($0, `ge_u`, [9223372036854775807n, -9223372036854775808n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/i64.wast:457
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.add (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:458
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.and (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:459
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.div_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:460
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.div_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:461
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.mul (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:462
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.or (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:463
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.rem_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:464
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.rem_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:465
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.rotl (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:466
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.rotr (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:467
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.shl (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:468
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.shr_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:469
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.shr_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:470
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.sub (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:471
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.xor (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:472
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.eqz (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:473
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.clz (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:474
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.ctz (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:475
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.popcnt (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:476
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.eq (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:477
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.ge_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:478
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.ge_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:479
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.gt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:480
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.gt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:481
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.le_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:482
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.le_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:483
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:484
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:485
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64.ne (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/i64.wast:487
+assert_malformed(
+  () => instantiate(`(func (result i64) (i64.const nan:arithmetic)) `),
+  `unexpected token`,
+);
+
+// ./test/core/i64.wast:491
+assert_malformed(
+  () => instantiate(`(func (result i64) (i64.const nan:canonical)) `),
+  `unexpected token`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/if.wast.js b/js/src/jit-test/tests/wasm/spec/spec/if.wast.js
new file mode 100644
index 0000000000..ada0bd224a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/if.wast.js
@@ -0,0 +1,1911 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/if.wast
+
+// ./test/core/if.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "empty") (param i32)
+    (if (local.get 0) (then))
+    (if (local.get 0) (then) (else))
+    (if $$l (local.get 0) (then))
+    (if $$l (local.get 0) (then) (else))
+  )
+
+  (func (export "singular") (param i32) (result i32)
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
+  )
+
+  (func (export "multi") (param i32) (result i32 i32)
+    (if (local.get 0) (then (call $$dummy) (call $$dummy) (call $$dummy)))
+    (if (local.get 0) (then) (else (call $$dummy) (call $$dummy) (call $$dummy)))
+    (if (result i32) (local.get 0)
+      (then (call $$dummy) (call $$dummy) (i32.const 8) (call $$dummy))
+      (else (call $$dummy) (call $$dummy) (i32.const 9) (call $$dummy))
+    )
+    (if (result i32 i64 i32) (local.get 0)
+      (then
+        (call $$dummy) (call $$dummy) (i32.const 1) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i64.const 2) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i32.const 3) (call $$dummy)
+      )
+      (else
+        (call $$dummy) (call $$dummy) (i32.const -1) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i64.const -2) (call $$dummy)
+        (call $$dummy) (call $$dummy) (i32.const -3) (call $$dummy)
+      )
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $$dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $$dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $$dummy) (i32.const 9))
+          (else (call $$dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $$dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $$dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $$dummy) (i32.const 10))
+          (else (call $$dummy) (i32.const 11))
+        )
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (i32.const 3)
+    )
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select
+      (i32.const 2) (i32.const 3)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (call $$dummy) (call $$dummy)
+    )
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32)
+      (call $$dummy)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (call $$dummy)
+    )
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32)
+      (call $$dummy) (call $$dummy)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (local.get 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $$dummy) (i32.const 2))
+      (else (call $$dummy) (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+        (i32.const 2)
+      )
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (i32.const 2)
+      (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32)
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 1))
+        (else (call $$dummy) (i32.const 0))
+      )
+      (br_table 0 0)
+    )
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+        (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+        (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (i32.const 0)
+        (if (result i32) (local.get 0)
+          (then (call $$dummy) (i32.const 1))
+          (else (call $$dummy) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (if (result i32) (local.get 0)
+      (then (call $$dummy) (i32.const 1))
+      (else (call $$dummy) (i32.const 0))
+    )
+    (i32.const 2)
+    (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 2)
+    (if (result i32) (local.get 0)
+      (then (call $$dummy) (i32.const 1))
+      (else (call $$dummy) (i32.const 0))
+    )
+    (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $$f
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (i32.const 1))
+      (else (i32.const 0)))
+    (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32)
+      (br 0
+        (if (result i32) (local.get 0)
+          (then (i32.const 1))
+          (else (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (local.set 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (global $$a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $$a
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    ) (global.get $$a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load
+      (if (result i32) (local.get 0)
+        (then (i32.const 11))
+        (else (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.ctz
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 13))
+        (else (call $$dummy) (i32.const -13))
+      )
+    )
+  )
+  (func (export "as-binary-operand") (param i32 i32) (result i32)
+    (i32.mul
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 3))
+        (else (call $$dummy) (i32.const -3))
+      )
+      (if (result i32) (local.get 1)
+        (then (call $$dummy) (i32.const 4))
+        (else (call $$dummy) (i32.const -5))
+      )
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz
+      (if (result i32) (local.get 0)
+        (then (call $$dummy) (i32.const 13))
+        (else (call $$dummy) (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-compare-operand") (param i32 i32) (result i32)
+    (f32.gt
+      (if (result f32) (local.get 0)
+        (then (call $$dummy) (f32.const 3))
+        (else (call $$dummy) (f32.const -3))
+      )
+      (if (result f32) (local.get 1)
+        (then (call $$dummy) (f32.const 4))
+        (else (call $$dummy) (f32.const -4))
+      )
+    )
+  )
+  (func (export "as-binary-operands") (param i32) (result i32)
+    (i32.mul
+      (if (result i32 i32) (local.get 0)
+        (then (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4))
+        (else (call $$dummy) (i32.const 3) (call $$dummy) (i32.const -4))
+      )
+    )
+  )
+  (func (export "as-compare-operands") (param i32) (result i32)
+    (f32.gt
+      (if (result f32 f32) (local.get 0)
+        (then (call $$dummy) (f32.const 3) (call $$dummy) (f32.const 3))
+        (else (call $$dummy) (f32.const -2) (call $$dummy) (f32.const -3))
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (param i32) (result i32)
+    (if (result i32 i32) (local.get 0)
+      (then (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4))
+      (else (call $$dummy) (i32.const -3) (call $$dummy) (i32.const -4))
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (if (i32.const 1) (then (br 0) (unreachable)))
+    (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable)))
+    (i32.const 19)
+  )
+
+  (func (export "break-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (br 0 (i32.const 18)) (i32.const 19))
+      (else (br 0 (i32.const 21)) (i32.const 20))
+    )
+  )
+  (func (export "break-multi-value") (param i32) (result i32 i32 i64)
+    (if (result i32 i32 i64) (local.get 0)
+      (then
+        (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+        (i32.const 19) (i32.const -19) (i64.const 19)
+      )
+      (else
+        (br 0 (i32.const -18) (i32.const 18) (i64.const -18))
+        (i32.const -19) (i32.const 19) (i64.const -19)
+      )
+    )
+  )
+
+  (func (export "param") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add))
+      (else (i32.const -2) (i32.add))
+    )
+  )
+  (func (export "params") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add))
+      (else (i32.sub))
+    )
+  )
+  (func (export "params-id") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then))
+    (i32.add)
+  )
+  (func (export "param-break") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add) (br 0))
+      (else (i32.const -2) (i32.add) (br 0))
+    )
+  )
+  (func (export "params-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add) (br 0))
+      (else (i32.sub) (br 0))
+    )
+  )
+  (func (export "params-id-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0)))
+    (i32.add)
+  )
+
+  (func (export "effects") (param i32) (result i32)
+    (local i32)
+    (if
+      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
+      (then
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
+      )
+      (else
+        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Examples
+
+  (func $$add64_u_with_carry (export "add64_u_with_carry")
+    (param $$i i64) (param $$j i64) (param $$c i32) (result i64 i32)
+    (local $$k i64)
+    (local.set $$k
+      (i64.add
+        (i64.add (local.get $$i) (local.get $$j))
+        (i64.extend_i32_u (local.get $$c))
+      )
+    )
+    (return (local.get $$k) (i64.lt_u (local.get $$k) (local.get $$i)))
+  )
+
+  (func $$add64_u_saturated (export "add64_u_saturated")
+    (param i64 i64) (result i64)
+    (call $$add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0))
+    (if (param i64) (result i64)
+      (then (drop) (i64.const -1))
+    )
+  )
+
+  ;; Block signature syntax
+
+  (type $$block-sig-1 (func))
+  (type $$block-sig-2 (func (result i32)))
+  (type $$block-sig-3 (func (param $$x i32)))
+  (type $$block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (if (type $$block-sig-1) (i32.const 1) (then))
+    (if (type $$block-sig-2) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $$block-sig-3) (i32.const 1) (then (drop)) (else (drop)))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $$block-sig-4) (i32.const 1) (then))
+    (drop) (drop) (drop)
+    (if (type $$block-sig-2) (result i32) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $$block-sig-3) (param i32) (i32.const 1)
+      (then (drop)) (else (drop))
+    )
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $$block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+      (i32.const 1) (then)
+    )
+    (drop) (drop) (drop)
+  )
+)`);
+
+// ./test/core/if.wast:529
+assert_return(() => invoke($0, `empty`, [0]), []);
+
+// ./test/core/if.wast:530
+assert_return(() => invoke($0, `empty`, [1]), []);
+
+// ./test/core/if.wast:531
+assert_return(() => invoke($0, `empty`, [100]), []);
+
+// ./test/core/if.wast:532
+assert_return(() => invoke($0, `empty`, [-2]), []);
+
+// ./test/core/if.wast:534
+assert_return(() => invoke($0, `singular`, [0]), [value("i32", 8)]);
+
+// ./test/core/if.wast:535
+assert_return(() => invoke($0, `singular`, [1]), [value("i32", 7)]);
+
+// ./test/core/if.wast:536
+assert_return(() => invoke($0, `singular`, [10]), [value("i32", 7)]);
+
+// ./test/core/if.wast:537
+assert_return(() => invoke($0, `singular`, [-10]), [value("i32", 7)]);
+
+// ./test/core/if.wast:539
+assert_return(() => invoke($0, `multi`, [0]), [value("i32", 9), value("i32", -1)]);
+
+// ./test/core/if.wast:540
+assert_return(() => invoke($0, `multi`, [1]), [value("i32", 8), value("i32", 1)]);
+
+// ./test/core/if.wast:541
+assert_return(() => invoke($0, `multi`, [13]), [value("i32", 8), value("i32", 1)]);
+
+// ./test/core/if.wast:542
+assert_return(() => invoke($0, `multi`, [-5]), [value("i32", 8), value("i32", 1)]);
+
+// ./test/core/if.wast:544
+assert_return(() => invoke($0, `nested`, [0, 0]), [value("i32", 11)]);
+
+// ./test/core/if.wast:545
+assert_return(() => invoke($0, `nested`, [1, 0]), [value("i32", 10)]);
+
+// ./test/core/if.wast:546
+assert_return(() => invoke($0, `nested`, [0, 1]), [value("i32", 10)]);
+
+// ./test/core/if.wast:547
+assert_return(() => invoke($0, `nested`, [3, 2]), [value("i32", 9)]);
+
+// ./test/core/if.wast:548
+assert_return(() => invoke($0, `nested`, [0, -100]), [value("i32", 10)]);
+
+// ./test/core/if.wast:549
+assert_return(() => invoke($0, `nested`, [10, 10]), [value("i32", 9)]);
+
+// ./test/core/if.wast:550
+assert_return(() => invoke($0, `nested`, [0, -1]), [value("i32", 10)]);
+
+// ./test/core/if.wast:551
+assert_return(() => invoke($0, `nested`, [-111, -2]), [value("i32", 9)]);
+
+// ./test/core/if.wast:553
+assert_return(() => invoke($0, `as-select-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:554
+assert_return(() => invoke($0, `as-select-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:555
+assert_return(() => invoke($0, `as-select-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:556
+assert_return(() => invoke($0, `as-select-mid`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:557
+assert_return(() => invoke($0, `as-select-last`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:558
+assert_return(() => invoke($0, `as-select-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:560
+assert_return(() => invoke($0, `as-loop-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:561
+assert_return(() => invoke($0, `as-loop-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:562
+assert_return(() => invoke($0, `as-loop-mid`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:563
+assert_return(() => invoke($0, `as-loop-mid`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:564
+assert_return(() => invoke($0, `as-loop-last`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:565
+assert_return(() => invoke($0, `as-loop-last`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:567
+assert_return(() => invoke($0, `as-if-condition`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:568
+assert_return(() => invoke($0, `as-if-condition`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:570
+assert_return(() => invoke($0, `as-br_if-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:571
+assert_return(() => invoke($0, `as-br_if-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:572
+assert_return(() => invoke($0, `as-br_if-last`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:573
+assert_return(() => invoke($0, `as-br_if-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:575
+assert_return(() => invoke($0, `as-br_table-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:576
+assert_return(() => invoke($0, `as-br_table-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:577
+assert_return(() => invoke($0, `as-br_table-last`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:578
+assert_return(() => invoke($0, `as-br_table-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:580
+assert_return(() => invoke($0, `as-call_indirect-first`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:581
+assert_return(() => invoke($0, `as-call_indirect-first`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:582
+assert_return(() => invoke($0, `as-call_indirect-mid`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:583
+assert_return(() => invoke($0, `as-call_indirect-mid`, [1]), [value("i32", 2)]);
+
+// ./test/core/if.wast:584
+assert_return(() => invoke($0, `as-call_indirect-last`, [0]), [value("i32", 2)]);
+
+// ./test/core/if.wast:585
+assert_trap(() => invoke($0, `as-call_indirect-last`, [1]), `undefined element`);
+
+// ./test/core/if.wast:587
+assert_return(() => invoke($0, `as-store-first`, [0]), []);
+
+// ./test/core/if.wast:588
+assert_return(() => invoke($0, `as-store-first`, [1]), []);
+
+// ./test/core/if.wast:589
+assert_return(() => invoke($0, `as-store-last`, [0]), []);
+
+// ./test/core/if.wast:590
+assert_return(() => invoke($0, `as-store-last`, [1]), []);
+
+// ./test/core/if.wast:592
+assert_return(() => invoke($0, `as-memory.grow-value`, [0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:593
+assert_return(() => invoke($0, `as-memory.grow-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:595
+assert_return(() => invoke($0, `as-call-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:596
+assert_return(() => invoke($0, `as-call-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:598
+assert_return(() => invoke($0, `as-return-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:599
+assert_return(() => invoke($0, `as-return-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:601
+assert_return(() => invoke($0, `as-drop-operand`, [0]), []);
+
+// ./test/core/if.wast:602
+assert_return(() => invoke($0, `as-drop-operand`, [1]), []);
+
+// ./test/core/if.wast:604
+assert_return(() => invoke($0, `as-br-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:605
+assert_return(() => invoke($0, `as-br-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:607
+assert_return(() => invoke($0, `as-local.set-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:608
+assert_return(() => invoke($0, `as-local.set-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:610
+assert_return(() => invoke($0, `as-local.tee-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:611
+assert_return(() => invoke($0, `as-local.tee-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:613
+assert_return(() => invoke($0, `as-global.set-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:614
+assert_return(() => invoke($0, `as-global.set-value`, [1]), [value("i32", 1)]);
+
+// ./test/core/if.wast:616
+assert_return(() => invoke($0, `as-load-operand`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:617
+assert_return(() => invoke($0, `as-load-operand`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:619
+assert_return(() => invoke($0, `as-unary-operand`, [0]), [value("i32", 0)]);
+
+// ./test/core/if.wast:620
+assert_return(() => invoke($0, `as-unary-operand`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:621
+assert_return(() => invoke($0, `as-unary-operand`, [-1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:623
+assert_return(() => invoke($0, `as-binary-operand`, [0, 0]), [value("i32", 15)]);
+
+// ./test/core/if.wast:624
+assert_return(() => invoke($0, `as-binary-operand`, [0, 1]), [value("i32", -12)]);
+
+// ./test/core/if.wast:625
+assert_return(() => invoke($0, `as-binary-operand`, [1, 0]), [value("i32", -15)]);
+
+// ./test/core/if.wast:626
+assert_return(() => invoke($0, `as-binary-operand`, [1, 1]), [value("i32", 12)]);
+
+// ./test/core/if.wast:628
+assert_return(() => invoke($0, `as-test-operand`, [0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:629
+assert_return(() => invoke($0, `as-test-operand`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:631
+assert_return(() => invoke($0, `as-compare-operand`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:632
+assert_return(() => invoke($0, `as-compare-operand`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:633
+assert_return(() => invoke($0, `as-compare-operand`, [1, 0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:634
+assert_return(() => invoke($0, `as-compare-operand`, [1, 1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:636
+assert_return(() => invoke($0, `as-binary-operands`, [0]), [value("i32", -12)]);
+
+// ./test/core/if.wast:637
+assert_return(() => invoke($0, `as-binary-operands`, [1]), [value("i32", 12)]);
+
+// ./test/core/if.wast:639
+assert_return(() => invoke($0, `as-compare-operands`, [0]), [value("i32", 1)]);
+
+// ./test/core/if.wast:640
+assert_return(() => invoke($0, `as-compare-operands`, [1]), [value("i32", 0)]);
+
+// ./test/core/if.wast:642
+assert_return(() => invoke($0, `as-mixed-operands`, [0]), [value("i32", -3)]);
+
+// ./test/core/if.wast:643
+assert_return(() => invoke($0, `as-mixed-operands`, [1]), [value("i32", 27)]);
+
+// ./test/core/if.wast:645
+assert_return(() => invoke($0, `break-bare`, []), [value("i32", 19)]);
+
+// ./test/core/if.wast:646
+assert_return(() => invoke($0, `break-value`, [1]), [value("i32", 18)]);
+
+// ./test/core/if.wast:647
+assert_return(() => invoke($0, `break-value`, [0]), [value("i32", 21)]);
+
+// ./test/core/if.wast:648
+assert_return(
+  () => invoke($0, `break-multi-value`, [0]),
+  [value("i32", -18), value("i32", 18), value("i64", -18n)],
+);
+
+// ./test/core/if.wast:651
+assert_return(
+  () => invoke($0, `break-multi-value`, [1]),
+  [value("i32", 18), value("i32", -18), value("i64", 18n)],
+);
+
+// ./test/core/if.wast:655
+assert_return(() => invoke($0, `param`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:656
+assert_return(() => invoke($0, `param`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:657
+assert_return(() => invoke($0, `params`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:658
+assert_return(() => invoke($0, `params`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:659
+assert_return(() => invoke($0, `params-id`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:660
+assert_return(() => invoke($0, `params-id`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:661
+assert_return(() => invoke($0, `param-break`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:662
+assert_return(() => invoke($0, `param-break`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:663
+assert_return(() => invoke($0, `params-break`, [0]), [value("i32", -1)]);
+
+// ./test/core/if.wast:664
+assert_return(() => invoke($0, `params-break`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:665
+assert_return(() => invoke($0, `params-id-break`, [0]), [value("i32", 3)]);
+
+// ./test/core/if.wast:666
+assert_return(() => invoke($0, `params-id-break`, [1]), [value("i32", 3)]);
+
+// ./test/core/if.wast:668
+assert_return(() => invoke($0, `effects`, [1]), [value("i32", -14)]);
+
+// ./test/core/if.wast:669
+assert_return(() => invoke($0, `effects`, [0]), [value("i32", -6)]);
+
+// ./test/core/if.wast:671
+assert_return(() => invoke($0, `add64_u_with_carry`, [0n, 0n, 0]), [value("i64", 0n), value("i32", 0)]);
+
+// ./test/core/if.wast:675
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [100n, 124n, 0]),
+  [value("i64", 224n), value("i32", 0)],
+);
+
+// ./test/core/if.wast:679
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [-1n, 0n, 0]),
+  [value("i64", -1n), value("i32", 0)],
+);
+
+// ./test/core/if.wast:683
+assert_return(() => invoke($0, `add64_u_with_carry`, [-1n, 1n, 0]), [value("i64", 0n), value("i32", 1)]);
+
+// ./test/core/if.wast:687
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [-1n, -1n, 0]),
+  [value("i64", -2n), value("i32", 1)],
+);
+
+// ./test/core/if.wast:691
+assert_return(() => invoke($0, `add64_u_with_carry`, [-1n, 0n, 1]), [value("i64", 0n), value("i32", 1)]);
+
+// ./test/core/if.wast:695
+assert_return(() => invoke($0, `add64_u_with_carry`, [-1n, 1n, 1]), [value("i64", 1n), value("i32", 1)]);
+
+// ./test/core/if.wast:699
+assert_return(
+  () => invoke($0, `add64_u_with_carry`, [
+    -9223372036854775808n,
+    -9223372036854775808n,
+    0,
+  ]),
+  [value("i64", 0n), value("i32", 1)],
+);
+
+// ./test/core/if.wast:704
+assert_return(() => invoke($0, `add64_u_saturated`, [0n, 0n]), [value("i64", 0n)]);
+
+// ./test/core/if.wast:707
+assert_return(() => invoke($0, `add64_u_saturated`, [1230n, 23n]), [value("i64", 1253n)]);
+
+// ./test/core/if.wast:710
+assert_return(() => invoke($0, `add64_u_saturated`, [-1n, 0n]), [value("i64", -1n)]);
+
+// ./test/core/if.wast:713
+assert_return(() => invoke($0, `add64_u_saturated`, [-1n, 1n]), [value("i64", -1n)]);
+
+// ./test/core/if.wast:716
+assert_return(() => invoke($0, `add64_u_saturated`, [-1n, -1n]), [value("i64", -1n)]);
+
+// ./test/core/if.wast:719
+assert_return(
+  () => invoke($0, `add64_u_saturated`, [-9223372036854775808n, -9223372036854775808n]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/if.wast:723
+assert_return(() => invoke($0, `type-use`, []), []);
+
+// ./test/core/if.wast:725
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (type $$sig) (result i32) (param i32) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:734
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (param i32) (type $$sig) (result i32) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:743
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (param i32) (result i32) (type $$sig) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:752
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (result i32) (type $$sig) (param i32) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:761
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0)   (if (result i32) (param i32) (type $$sig) (i32.const 1) (then)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:770
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then))) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:777
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (i32.const 1)   (if (param $$x i32) (then (drop)) (else (drop))) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:785
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (func (i32.const 1)   (if (type $$sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))   (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:795
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 1)   (if (type $$sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))   (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:805
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (i32.const 1)   (if (type $$sig) (param i32) (then (drop)) (else (drop)))   (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:815
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (func (i32.const 0) (i32.const 1)   (if (type $$sig) (param i32) (result i32) (then)) (unreachable) ) `),
+  `inline function type`,
+);
+
+// ./test/core/if.wast:825
+assert_invalid(
+  () => instantiate(`(module
+    (type $$sig (func))
+    (func (i32.const 1) (if (type $$sig) (i32.const 0) (then)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:833
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:837
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:841
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:845
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64) (if (i32.const 0) (then))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:850
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:854
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:858
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:862
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64) (if (i32.const 0) (then) (else))))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:867
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:873
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-void-else
+    (if (i32.const 1) (then (i32.const 1)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:879
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-num-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:885
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:892
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:898
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-nums-vs-void-else
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:904
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-nums-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:910
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:917
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:923
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:929
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:936
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:942
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:948
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:955
+assert_invalid(
+  () => instantiate(`(module (func $$type-no-else-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:961
+assert_invalid(
+  () => instantiate(`(module (func $$type-no-else-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:968
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:974
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:980
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:987
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:993
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:999
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1006
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1012
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1018
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1025
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1031
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1037
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1044
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1051
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1058
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1066
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1072
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1078
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1085
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-different-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1091
+assert_invalid(
+  () => instantiate(`(module (func $$type-both-different-value-nums-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1098
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 0)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (i64.const 0))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1108
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (i64.const 0))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1118
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1129
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1135
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1141
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1147
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1154
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1163
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1172
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1181
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0) (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1191
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1200
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1209
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1218
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1228
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1237
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1246
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1255
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1264
+assert_invalid(
+  () => instantiate(`(module (func $$type-then-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1274
+assert_invalid(
+  () => instantiate(`(module (func $$type-else-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1285
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty
+      (if (then))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1293
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-block
+      (i32.const 0)
+      (block (if (then)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1302
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-loop
+      (i32.const 0)
+      (loop (if (then)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1311
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (if (then))))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1320
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0)))
+      (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1330
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-br
+      (i32.const 0)
+      (block (br 0 (if(then))) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1339
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (if(then)) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1348
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (if(then))) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1357
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-return
+      (return (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1365
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-select
+      (select (if(then)) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1373
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-call
+      (call 1 (if(then))) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1382
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-condition-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (if(then)) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1398
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-local.set
+      (local i32)
+      (local.set 0 (if(then))) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1407
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-condition-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1416
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-condition-empty-in-global.set
+      (global.set $$x (if(then))) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1425
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-condition-empty-in-memory.grow
+      (memory.grow (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1434
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-condition-empty-in-load
+      (i32.load (if(then))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1443
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-condition-empty-in-store
+      (i32.store (if(then)) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1453
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-num
+    (if (param i32) (i32.const 1) (then (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1459
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (if (param i32 f64) (i32.const 1) (then (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1465
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1471
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1477
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-nested-void-vs-num
+    (block (if (param i32) (i32.const 1) (then (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1483
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (block (if (param i32 f64) (i32.const 1) (then (drop) (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1489
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1495
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/if.wast:1502
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) if (param $$x i32) end) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:1506
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) (if (param $$x i32) (then))) `),
+  `unexpected token`,
+);
+
+// ./test/core/if.wast:1511
+assert_malformed(() => instantiate(`(func i32.const 0 if end $$l) `), `mismatching label`);
+
+// ./test/core/if.wast:1515
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1519
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else $$l end) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1523
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else $$l end) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1527
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1531
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else $$l end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1535
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if else $$l1 end $$l2) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1539
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1543
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else $$a end $$l) `),
+  `mismatching label`,
+);
+
+// ./test/core/if.wast:1547
+assert_malformed(
+  () => instantiate(`(func i32.const 0 if $$a else $$l end $$l) `),
+  `mismatching label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/inline-module.wast.js b/js/src/jit-test/tests/wasm/spec/spec/inline-module.wast.js
new file mode 100644
index 0000000000..30e6acaeee
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/inline-module.wast.js
@@ -0,0 +1,20 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/inline-module.wast
+
+// ./test/core/inline-module.wast:1:0
+let $0 = instantiate(`(func) (memory 0) (func (export "f"))
+`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js b/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js
new file mode 100644
index 0000000000..811712a794
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js
@@ -0,0 +1,534 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/int_exprs.wast
+
+// ./test/core/int_exprs.wast:6
+let $0 = instantiate(`(module
+  (func (export "i32.no_fold_cmp_s_offset") (param $$x i32) (param $$y i32) (result i32)
+    (i32.lt_s (i32.add (local.get $$x) (i32.const 1)) (i32.add (local.get $$y) (i32.const 1))))
+  (func (export "i32.no_fold_cmp_u_offset") (param $$x i32) (param $$y i32) (result i32)
+    (i32.lt_u (i32.add (local.get $$x) (i32.const 1)) (i32.add (local.get $$y) (i32.const 1))))
+
+  (func (export "i64.no_fold_cmp_s_offset") (param $$x i64) (param $$y i64) (result i32)
+    (i64.lt_s (i64.add (local.get $$x) (i64.const 1)) (i64.add (local.get $$y) (i64.const 1))))
+  (func (export "i64.no_fold_cmp_u_offset") (param $$x i64) (param $$y i64) (result i32)
+    (i64.lt_u (i64.add (local.get $$x) (i64.const 1)) (i64.add (local.get $$y) (i64.const 1))))
+)`);
+
+// ./test/core/int_exprs.wast:18
+assert_return(() => invoke($0, `i32.no_fold_cmp_s_offset`, [2147483647, 0]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:19
+assert_return(() => invoke($0, `i32.no_fold_cmp_u_offset`, [-1, 0]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:20
+assert_return(
+  () => invoke($0, `i64.no_fold_cmp_s_offset`, [9223372036854775807n, 0n]),
+  [value("i32", 1)],
+);
+
+// ./test/core/int_exprs.wast:21
+assert_return(() => invoke($0, `i64.no_fold_cmp_u_offset`, [-1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:25
+let $1 = instantiate(`(module
+  (func (export "i64.no_fold_wrap_extend_s") (param $$x i64) (result i64)
+    (i64.extend_i32_s (i32.wrap_i64 (local.get $$x))))
+)`);
+
+// ./test/core/int_exprs.wast:30
+assert_return(
+  () => invoke($1, `i64.no_fold_wrap_extend_s`, [4538991236898928n]),
+  [value("i64", 1079009392n)],
+);
+
+// ./test/core/int_exprs.wast:31
+assert_return(
+  () => invoke($1, `i64.no_fold_wrap_extend_s`, [45230338458316960n]),
+  [value("i64", -790564704n)],
+);
+
+// ./test/core/int_exprs.wast:35
+let $2 = instantiate(`(module
+  (func (export "i64.no_fold_wrap_extend_u") (param $$x i64) (result i64)
+    (i64.extend_i32_u (i32.wrap_i64 (local.get $$x))))
+)`);
+
+// ./test/core/int_exprs.wast:40
+assert_return(
+  () => invoke($2, `i64.no_fold_wrap_extend_u`, [4538991236898928n]),
+  [value("i64", 1079009392n)],
+);
+
+// ./test/core/int_exprs.wast:44
+let $3 = instantiate(`(module
+  (func (export "i32.no_fold_shl_shr_s") (param $$x i32) (result i32)
+    (i32.shr_s (i32.shl (local.get $$x) (i32.const 1)) (i32.const 1)))
+  (func (export "i32.no_fold_shl_shr_u") (param $$x i32) (result i32)
+    (i32.shr_u (i32.shl (local.get $$x) (i32.const 1)) (i32.const 1)))
+
+  (func (export "i64.no_fold_shl_shr_s") (param $$x i64) (result i64)
+    (i64.shr_s (i64.shl (local.get $$x) (i64.const 1)) (i64.const 1)))
+  (func (export "i64.no_fold_shl_shr_u") (param $$x i64) (result i64)
+    (i64.shr_u (i64.shl (local.get $$x) (i64.const 1)) (i64.const 1)))
+)`);
+
+// ./test/core/int_exprs.wast:56
+assert_return(() => invoke($3, `i32.no_fold_shl_shr_s`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:57
+assert_return(() => invoke($3, `i32.no_fold_shl_shr_u`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:58
+assert_return(() => invoke($3, `i64.no_fold_shl_shr_s`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:59
+assert_return(() => invoke($3, `i64.no_fold_shl_shr_u`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:63
+let $4 = instantiate(`(module
+  (func (export "i32.no_fold_shr_s_shl") (param $$x i32) (result i32)
+    (i32.shl (i32.shr_s (local.get $$x) (i32.const 1)) (i32.const 1)))
+  (func (export "i32.no_fold_shr_u_shl") (param $$x i32) (result i32)
+    (i32.shl (i32.shr_u (local.get $$x) (i32.const 1)) (i32.const 1)))
+
+  (func (export "i64.no_fold_shr_s_shl") (param $$x i64) (result i64)
+    (i64.shl (i64.shr_s (local.get $$x) (i64.const 1)) (i64.const 1)))
+  (func (export "i64.no_fold_shr_u_shl") (param $$x i64) (result i64)
+    (i64.shl (i64.shr_u (local.get $$x) (i64.const 1)) (i64.const 1)))
+)`);
+
+// ./test/core/int_exprs.wast:75
+assert_return(() => invoke($4, `i32.no_fold_shr_s_shl`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:76
+assert_return(() => invoke($4, `i32.no_fold_shr_u_shl`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:77
+assert_return(() => invoke($4, `i64.no_fold_shr_s_shl`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:78
+assert_return(() => invoke($4, `i64.no_fold_shr_u_shl`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:82
+let $5 = instantiate(`(module
+  (func (export "i32.no_fold_div_s_mul") (param $$x i32) (result i32)
+    (i32.mul (i32.div_s (local.get $$x) (i32.const 6)) (i32.const 6)))
+  (func (export "i32.no_fold_div_u_mul") (param $$x i32) (result i32)
+    (i32.mul (i32.div_u (local.get $$x) (i32.const 6)) (i32.const 6)))
+
+  (func (export "i64.no_fold_div_s_mul") (param $$x i64) (result i64)
+    (i64.mul (i64.div_s (local.get $$x) (i64.const 6)) (i64.const 6)))
+  (func (export "i64.no_fold_div_u_mul") (param $$x i64) (result i64)
+    (i64.mul (i64.div_u (local.get $$x) (i64.const 6)) (i64.const 6)))
+)`);
+
+// ./test/core/int_exprs.wast:94
+assert_return(() => invoke($5, `i32.no_fold_div_s_mul`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:95
+assert_return(() => invoke($5, `i32.no_fold_div_u_mul`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:96
+assert_return(() => invoke($5, `i64.no_fold_div_s_mul`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:97
+assert_return(() => invoke($5, `i64.no_fold_div_u_mul`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:101
+let $6 = instantiate(`(module
+  (func (export "i32.no_fold_div_s_self") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (local.get $$x)))
+  (func (export "i32.no_fold_div_u_self") (param $$x i32) (result i32)
+    (i32.div_u (local.get $$x) (local.get $$x)))
+
+  (func (export "i64.no_fold_div_s_self") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (local.get $$x)))
+  (func (export "i64.no_fold_div_u_self") (param $$x i64) (result i64)
+    (i64.div_u (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/int_exprs.wast:113
+assert_trap(() => invoke($6, `i32.no_fold_div_s_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:114
+assert_trap(() => invoke($6, `i32.no_fold_div_u_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:115
+assert_trap(() => invoke($6, `i64.no_fold_div_s_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:116
+assert_trap(() => invoke($6, `i64.no_fold_div_u_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:120
+let $7 = instantiate(`(module
+  (func (export "i32.no_fold_rem_s_self") (param $$x i32) (result i32)
+    (i32.rem_s (local.get $$x) (local.get $$x)))
+  (func (export "i32.no_fold_rem_u_self") (param $$x i32) (result i32)
+    (i32.rem_u (local.get $$x) (local.get $$x)))
+
+  (func (export "i64.no_fold_rem_s_self") (param $$x i64) (result i64)
+    (i64.rem_s (local.get $$x) (local.get $$x)))
+  (func (export "i64.no_fold_rem_u_self") (param $$x i64) (result i64)
+    (i64.rem_u (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/int_exprs.wast:132
+assert_trap(() => invoke($7, `i32.no_fold_rem_s_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:133
+assert_trap(() => invoke($7, `i32.no_fold_rem_u_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:134
+assert_trap(() => invoke($7, `i64.no_fold_rem_s_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:135
+assert_trap(() => invoke($7, `i64.no_fold_rem_u_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:139
+let $8 = instantiate(`(module
+  (func (export "i32.no_fold_mul_div_s") (param $$x i32) (result i32)
+    (i32.div_s (i32.mul (local.get $$x) (i32.const 6)) (i32.const 6)))
+  (func (export "i32.no_fold_mul_div_u") (param $$x i32) (result i32)
+    (i32.div_u (i32.mul (local.get $$x) (i32.const 6)) (i32.const 6)))
+
+  (func (export "i64.no_fold_mul_div_s") (param $$x i64) (result i64)
+    (i64.div_s (i64.mul (local.get $$x) (i64.const 6)) (i64.const 6)))
+  (func (export "i64.no_fold_mul_div_u") (param $$x i64) (result i64)
+    (i64.div_u (i64.mul (local.get $$x) (i64.const 6)) (i64.const 6)))
+)`);
+
+// ./test/core/int_exprs.wast:151
+assert_return(() => invoke($8, `i32.no_fold_mul_div_s`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:152
+assert_return(() => invoke($8, `i32.no_fold_mul_div_u`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:153
+assert_return(() => invoke($8, `i64.no_fold_mul_div_s`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:154
+assert_return(() => invoke($8, `i64.no_fold_mul_div_u`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:158
+let $9 = instantiate(`(module
+  (func (export "i32.no_fold_div_s_2") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (i32.const 2)))
+
+  (func (export "i64.no_fold_div_s_2") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (i64.const 2)))
+)`);
+
+// ./test/core/int_exprs.wast:166
+assert_return(() => invoke($9, `i32.no_fold_div_s_2`, [-11]), [value("i32", -5)]);
+
+// ./test/core/int_exprs.wast:167
+assert_return(() => invoke($9, `i64.no_fold_div_s_2`, [-11n]), [value("i64", -5n)]);
+
+// ./test/core/int_exprs.wast:171
+let $10 = instantiate(`(module
+  (func (export "i32.no_fold_rem_s_2") (param $$x i32) (result i32)
+    (i32.rem_s (local.get $$x) (i32.const 2)))
+
+  (func (export "i64.no_fold_rem_s_2") (param $$x i64) (result i64)
+    (i64.rem_s (local.get $$x) (i64.const 2)))
+)`);
+
+// ./test/core/int_exprs.wast:179
+assert_return(() => invoke($10, `i32.no_fold_rem_s_2`, [-11]), [value("i32", -1)]);
+
+// ./test/core/int_exprs.wast:180
+assert_return(() => invoke($10, `i64.no_fold_rem_s_2`, [-11n]), [value("i64", -1n)]);
+
+// ./test/core/int_exprs.wast:184
+let $11 = instantiate(`(module
+  (func (export "i32.div_s_0") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (i32.const 0)))
+  (func (export "i32.div_u_0") (param $$x i32) (result i32)
+    (i32.div_u (local.get $$x) (i32.const 0)))
+
+  (func (export "i64.div_s_0") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (i64.const 0)))
+  (func (export "i64.div_u_0") (param $$x i64) (result i64)
+    (i64.div_u (local.get $$x) (i64.const 0)))
+)`);
+
+// ./test/core/int_exprs.wast:196
+assert_trap(() => invoke($11, `i32.div_s_0`, [71]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:197
+assert_trap(() => invoke($11, `i32.div_u_0`, [71]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:198
+assert_trap(() => invoke($11, `i64.div_s_0`, [71n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:199
+assert_trap(() => invoke($11, `i64.div_u_0`, [71n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:203
+let $12 = instantiate(`(module
+  (func (export "i32.div_s_3") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (i32.const 3)))
+  (func (export "i32.div_u_3") (param $$x i32) (result i32)
+    (i32.div_u (local.get $$x) (i32.const 3)))
+
+  (func (export "i64.div_s_3") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (i64.const 3)))
+  (func (export "i64.div_u_3") (param $$x i64) (result i64)
+    (i64.div_u (local.get $$x) (i64.const 3)))
+)`);
+
+// ./test/core/int_exprs.wast:215
+assert_return(() => invoke($12, `i32.div_s_3`, [71]), [value("i32", 23)]);
+
+// ./test/core/int_exprs.wast:216
+assert_return(() => invoke($12, `i32.div_s_3`, [1610612736]), [value("i32", 536870912)]);
+
+// ./test/core/int_exprs.wast:217
+assert_return(() => invoke($12, `i32.div_u_3`, [71]), [value("i32", 23)]);
+
+// ./test/core/int_exprs.wast:218
+assert_return(() => invoke($12, `i32.div_u_3`, [-1073741824]), [value("i32", 1073741824)]);
+
+// ./test/core/int_exprs.wast:219
+assert_return(() => invoke($12, `i64.div_s_3`, [71n]), [value("i64", 23n)]);
+
+// ./test/core/int_exprs.wast:220
+assert_return(
+  () => invoke($12, `i64.div_s_3`, [3458764513820540928n]),
+  [value("i64", 1152921504606846976n)],
+);
+
+// ./test/core/int_exprs.wast:221
+assert_return(() => invoke($12, `i64.div_u_3`, [71n]), [value("i64", 23n)]);
+
+// ./test/core/int_exprs.wast:222
+assert_return(
+  () => invoke($12, `i64.div_u_3`, [-4611686018427387904n]),
+  [value("i64", 4611686018427387904n)],
+);
+
+// ./test/core/int_exprs.wast:226
+let $13 = instantiate(`(module
+  (func (export "i32.div_s_5") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (i32.const 5)))
+  (func (export "i32.div_u_5") (param $$x i32) (result i32)
+    (i32.div_u (local.get $$x) (i32.const 5)))
+
+  (func (export "i64.div_s_5") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (i64.const 5)))
+  (func (export "i64.div_u_5") (param $$x i64) (result i64)
+    (i64.div_u (local.get $$x) (i64.const 5)))
+)`);
+
+// ./test/core/int_exprs.wast:238
+assert_return(() => invoke($13, `i32.div_s_5`, [71]), [value("i32", 14)]);
+
+// ./test/core/int_exprs.wast:239
+assert_return(() => invoke($13, `i32.div_s_5`, [1342177280]), [value("i32", 268435456)]);
+
+// ./test/core/int_exprs.wast:240
+assert_return(() => invoke($13, `i32.div_u_5`, [71]), [value("i32", 14)]);
+
+// ./test/core/int_exprs.wast:241
+assert_return(() => invoke($13, `i32.div_u_5`, [-1610612736]), [value("i32", 536870912)]);
+
+// ./test/core/int_exprs.wast:242
+assert_return(() => invoke($13, `i64.div_s_5`, [71n]), [value("i64", 14n)]);
+
+// ./test/core/int_exprs.wast:243
+assert_return(
+  () => invoke($13, `i64.div_s_5`, [5764607523034234880n]),
+  [value("i64", 1152921504606846976n)],
+);
+
+// ./test/core/int_exprs.wast:244
+assert_return(() => invoke($13, `i64.div_u_5`, [71n]), [value("i64", 14n)]);
+
+// ./test/core/int_exprs.wast:245
+assert_return(
+  () => invoke($13, `i64.div_u_5`, [-6917529027641081856n]),
+  [value("i64", 2305843009213693952n)],
+);
+
+// ./test/core/int_exprs.wast:249
+let $14 = instantiate(`(module
+  (func (export "i32.div_s_7") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (i32.const 7)))
+  (func (export "i32.div_u_7") (param $$x i32) (result i32)
+    (i32.div_u (local.get $$x) (i32.const 7)))
+
+  (func (export "i64.div_s_7") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (i64.const 7)))
+  (func (export "i64.div_u_7") (param $$x i64) (result i64)
+    (i64.div_u (local.get $$x) (i64.const 7)))
+)`);
+
+// ./test/core/int_exprs.wast:261
+assert_return(() => invoke($14, `i32.div_s_7`, [71]), [value("i32", 10)]);
+
+// ./test/core/int_exprs.wast:262
+assert_return(() => invoke($14, `i32.div_s_7`, [1879048192]), [value("i32", 268435456)]);
+
+// ./test/core/int_exprs.wast:263
+assert_return(() => invoke($14, `i32.div_u_7`, [71]), [value("i32", 10)]);
+
+// ./test/core/int_exprs.wast:264
+assert_return(() => invoke($14, `i32.div_u_7`, [-536870912]), [value("i32", 536870912)]);
+
+// ./test/core/int_exprs.wast:265
+assert_return(() => invoke($14, `i64.div_s_7`, [71n]), [value("i64", 10n)]);
+
+// ./test/core/int_exprs.wast:266
+assert_return(
+  () => invoke($14, `i64.div_s_7`, [8070450532247928832n]),
+  [value("i64", 1152921504606846976n)],
+);
+
+// ./test/core/int_exprs.wast:267
+assert_return(() => invoke($14, `i64.div_u_7`, [71n]), [value("i64", 10n)]);
+
+// ./test/core/int_exprs.wast:268
+assert_return(
+  () => invoke($14, `i64.div_u_7`, [-2305843009213693952n]),
+  [value("i64", 2305843009213693952n)],
+);
+
+// ./test/core/int_exprs.wast:272
+let $15 = instantiate(`(module
+  (func (export "i32.rem_s_3") (param $$x i32) (result i32)
+    (i32.rem_s (local.get $$x) (i32.const 3)))
+  (func (export "i32.rem_u_3") (param $$x i32) (result i32)
+    (i32.rem_u (local.get $$x) (i32.const 3)))
+
+  (func (export "i64.rem_s_3") (param $$x i64) (result i64)
+    (i64.rem_s (local.get $$x) (i64.const 3)))
+  (func (export "i64.rem_u_3") (param $$x i64) (result i64)
+    (i64.rem_u (local.get $$x) (i64.const 3)))
+)`);
+
+// ./test/core/int_exprs.wast:284
+assert_return(() => invoke($15, `i32.rem_s_3`, [71]), [value("i32", 2)]);
+
+// ./test/core/int_exprs.wast:285
+assert_return(() => invoke($15, `i32.rem_s_3`, [1610612736]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:286
+assert_return(() => invoke($15, `i32.rem_u_3`, [71]), [value("i32", 2)]);
+
+// ./test/core/int_exprs.wast:287
+assert_return(() => invoke($15, `i32.rem_u_3`, [-1073741824]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:288
+assert_return(() => invoke($15, `i64.rem_s_3`, [71n]), [value("i64", 2n)]);
+
+// ./test/core/int_exprs.wast:289
+assert_return(() => invoke($15, `i64.rem_s_3`, [3458764513820540928n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:290
+assert_return(() => invoke($15, `i64.rem_u_3`, [71n]), [value("i64", 2n)]);
+
+// ./test/core/int_exprs.wast:291
+assert_return(() => invoke($15, `i64.rem_u_3`, [-4611686018427387904n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:295
+let $16 = instantiate(`(module
+  (func (export "i32.rem_s_5") (param $$x i32) (result i32)
+    (i32.rem_s (local.get $$x) (i32.const 5)))
+  (func (export "i32.rem_u_5") (param $$x i32) (result i32)
+    (i32.rem_u (local.get $$x) (i32.const 5)))
+
+  (func (export "i64.rem_s_5") (param $$x i64) (result i64)
+    (i64.rem_s (local.get $$x) (i64.const 5)))
+  (func (export "i64.rem_u_5") (param $$x i64) (result i64)
+    (i64.rem_u (local.get $$x) (i64.const 5)))
+)`);
+
+// ./test/core/int_exprs.wast:307
+assert_return(() => invoke($16, `i32.rem_s_5`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:308
+assert_return(() => invoke($16, `i32.rem_s_5`, [1342177280]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:309
+assert_return(() => invoke($16, `i32.rem_u_5`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:310
+assert_return(() => invoke($16, `i32.rem_u_5`, [-1610612736]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:311
+assert_return(() => invoke($16, `i64.rem_s_5`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:312
+assert_return(() => invoke($16, `i64.rem_s_5`, [5764607523034234880n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:313
+assert_return(() => invoke($16, `i64.rem_u_5`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:314
+assert_return(() => invoke($16, `i64.rem_u_5`, [-6917529027641081856n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:318
+let $17 = instantiate(`(module
+  (func (export "i32.rem_s_7") (param $$x i32) (result i32)
+    (i32.rem_s (local.get $$x) (i32.const 7)))
+  (func (export "i32.rem_u_7") (param $$x i32) (result i32)
+    (i32.rem_u (local.get $$x) (i32.const 7)))
+
+  (func (export "i64.rem_s_7") (param $$x i64) (result i64)
+    (i64.rem_s (local.get $$x) (i64.const 7)))
+  (func (export "i64.rem_u_7") (param $$x i64) (result i64)
+    (i64.rem_u (local.get $$x) (i64.const 7)))
+)`);
+
+// ./test/core/int_exprs.wast:330
+assert_return(() => invoke($17, `i32.rem_s_7`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:331
+assert_return(() => invoke($17, `i32.rem_s_7`, [1879048192]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:332
+assert_return(() => invoke($17, `i32.rem_u_7`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:333
+assert_return(() => invoke($17, `i32.rem_u_7`, [-536870912]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:334
+assert_return(() => invoke($17, `i64.rem_s_7`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:335
+assert_return(() => invoke($17, `i64.rem_s_7`, [8070450532247928832n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:336
+assert_return(() => invoke($17, `i64.rem_u_7`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:337
+assert_return(() => invoke($17, `i64.rem_u_7`, [-2305843009213693952n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:341
+let $18 = instantiate(`(module
+  (func (export "i32.no_fold_div_neg1") (param $$x i32) (result i32)
+    (i32.div_s (local.get $$x) (i32.const -1)))
+
+  (func (export "i64.no_fold_div_neg1") (param $$x i64) (result i64)
+    (i64.div_s (local.get $$x) (i64.const -1)))
+)`);
+
+// ./test/core/int_exprs.wast:349
+assert_trap(() => invoke($18, `i32.no_fold_div_neg1`, [-2147483648]), `integer overflow`);
+
+// ./test/core/int_exprs.wast:350
+assert_trap(() => invoke($18, `i64.no_fold_div_neg1`, [-9223372036854775808n]), `integer overflow`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/int_literals.wast.js b/js/src/jit-test/tests/wasm/spec/spec/int_literals.wast.js
new file mode 100644
index 0000000000..348aeda4ea
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/int_literals.wast.js
@@ -0,0 +1,233 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/int_literals.wast
+
+// ./test/core/int_literals.wast:1
+let $0 = instantiate(`(module
+  (func (export "i32.test") (result i32) (return (i32.const 0x0bAdD00D)))
+  (func (export "i32.umax") (result i32) (return (i32.const 0xffffffff)))
+  (func (export "i32.smax") (result i32) (return (i32.const 0x7fffffff)))
+  (func (export "i32.neg_smax") (result i32) (return (i32.const -0x7fffffff)))
+  (func (export "i32.smin") (result i32) (return (i32.const -0x80000000)))
+  (func (export "i32.alt_smin") (result i32) (return (i32.const 0x80000000)))
+  (func (export "i32.inc_smin") (result i32) (return (i32.add (i32.const -0x80000000) (i32.const 1))))
+  (func (export "i32.neg_zero") (result i32) (return (i32.const -0x0)))
+  (func (export "i32.not_octal") (result i32) (return (i32.const 010)))
+  (func (export "i32.unsigned_decimal") (result i32) (return (i32.const 4294967295)))
+  (func (export "i32.plus_sign") (result i32) (return (i32.const +42)))
+
+  (func (export "i64.test") (result i64) (return (i64.const 0x0CABBA6E0ba66a6e)))
+  (func (export "i64.umax") (result i64) (return (i64.const 0xffffffffffffffff)))
+  (func (export "i64.smax") (result i64) (return (i64.const 0x7fffffffffffffff)))
+  (func (export "i64.neg_smax") (result i64) (return (i64.const -0x7fffffffffffffff)))
+  (func (export "i64.smin") (result i64) (return (i64.const -0x8000000000000000)))
+  (func (export "i64.alt_smin") (result i64) (return (i64.const 0x8000000000000000)))
+  (func (export "i64.inc_smin") (result i64) (return (i64.add (i64.const -0x8000000000000000) (i64.const 1))))
+  (func (export "i64.neg_zero") (result i64) (return (i64.const -0x0)))
+  (func (export "i64.not_octal") (result i64) (return (i64.const 010)))
+  (func (export "i64.unsigned_decimal") (result i64) (return (i64.const 18446744073709551615)))
+  (func (export "i64.plus_sign") (result i64) (return (i64.const +42)))
+
+  (func (export "i32-dec-sep1") (result i32) (i32.const 1_000_000))
+  (func (export "i32-dec-sep2") (result i32) (i32.const 1_0_0_0))
+  (func (export "i32-hex-sep1") (result i32) (i32.const 0xa_0f_00_99))
+  (func (export "i32-hex-sep2") (result i32) (i32.const 0x1_a_A_0_f))
+
+  (func (export "i64-dec-sep1") (result i64) (i64.const 1_000_000))
+  (func (export "i64-dec-sep2") (result i64) (i64.const 1_0_0_0))
+  (func (export "i64-hex-sep1") (result i64) (i64.const 0xa_f00f_0000_9999))
+  (func (export "i64-hex-sep2") (result i64) (i64.const 0x1_a_A_0_f))
+)`);
+
+// ./test/core/int_literals.wast:37
+assert_return(() => invoke($0, `i32.test`, []), [value("i32", 195940365)]);
+
+// ./test/core/int_literals.wast:38
+assert_return(() => invoke($0, `i32.umax`, []), [value("i32", -1)]);
+
+// ./test/core/int_literals.wast:39
+assert_return(() => invoke($0, `i32.smax`, []), [value("i32", 2147483647)]);
+
+// ./test/core/int_literals.wast:40
+assert_return(() => invoke($0, `i32.neg_smax`, []), [value("i32", -2147483647)]);
+
+// ./test/core/int_literals.wast:41
+assert_return(() => invoke($0, `i32.smin`, []), [value("i32", -2147483648)]);
+
+// ./test/core/int_literals.wast:42
+assert_return(() => invoke($0, `i32.alt_smin`, []), [value("i32", -2147483648)]);
+
+// ./test/core/int_literals.wast:43
+assert_return(() => invoke($0, `i32.inc_smin`, []), [value("i32", -2147483647)]);
+
+// ./test/core/int_literals.wast:44
+assert_return(() => invoke($0, `i32.neg_zero`, []), [value("i32", 0)]);
+
+// ./test/core/int_literals.wast:45
+assert_return(() => invoke($0, `i32.not_octal`, []), [value("i32", 10)]);
+
+// ./test/core/int_literals.wast:46
+assert_return(() => invoke($0, `i32.unsigned_decimal`, []), [value("i32", -1)]);
+
+// ./test/core/int_literals.wast:47
+assert_return(() => invoke($0, `i32.plus_sign`, []), [value("i32", 42)]);
+
+// ./test/core/int_literals.wast:49
+assert_return(() => invoke($0, `i64.test`, []), [value("i64", 913028331277281902n)]);
+
+// ./test/core/int_literals.wast:50
+assert_return(() => invoke($0, `i64.umax`, []), [value("i64", -1n)]);
+
+// ./test/core/int_literals.wast:51
+assert_return(() => invoke($0, `i64.smax`, []), [value("i64", 9223372036854775807n)]);
+
+// ./test/core/int_literals.wast:52
+assert_return(() => invoke($0, `i64.neg_smax`, []), [value("i64", -9223372036854775807n)]);
+
+// ./test/core/int_literals.wast:53
+assert_return(() => invoke($0, `i64.smin`, []), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/int_literals.wast:54
+assert_return(() => invoke($0, `i64.alt_smin`, []), [value("i64", -9223372036854775808n)]);
+
+// ./test/core/int_literals.wast:55
+assert_return(() => invoke($0, `i64.inc_smin`, []), [value("i64", -9223372036854775807n)]);
+
+// ./test/core/int_literals.wast:56
+assert_return(() => invoke($0, `i64.neg_zero`, []), [value("i64", 0n)]);
+
+// ./test/core/int_literals.wast:57
+assert_return(() => invoke($0, `i64.not_octal`, []), [value("i64", 10n)]);
+
+// ./test/core/int_literals.wast:58
+assert_return(() => invoke($0, `i64.unsigned_decimal`, []), [value("i64", -1n)]);
+
+// ./test/core/int_literals.wast:59
+assert_return(() => invoke($0, `i64.plus_sign`, []), [value("i64", 42n)]);
+
+// ./test/core/int_literals.wast:61
+assert_return(() => invoke($0, `i32-dec-sep1`, []), [value("i32", 1000000)]);
+
+// ./test/core/int_literals.wast:62
+assert_return(() => invoke($0, `i32-dec-sep2`, []), [value("i32", 1000)]);
+
+// ./test/core/int_literals.wast:63
+assert_return(() => invoke($0, `i32-hex-sep1`, []), [value("i32", 168755353)]);
+
+// ./test/core/int_literals.wast:64
+assert_return(() => invoke($0, `i32-hex-sep2`, []), [value("i32", 109071)]);
+
+// ./test/core/int_literals.wast:66
+assert_return(() => invoke($0, `i64-dec-sep1`, []), [value("i64", 1000000n)]);
+
+// ./test/core/int_literals.wast:67
+assert_return(() => invoke($0, `i64-dec-sep2`, []), [value("i64", 1000n)]);
+
+// ./test/core/int_literals.wast:68
+assert_return(() => invoke($0, `i64-hex-sep1`, []), [value("i64", 3078696982321561n)]);
+
+// ./test/core/int_literals.wast:69
+assert_return(() => invoke($0, `i64-hex-sep2`, []), [value("i64", 109071n)]);
+
+// ./test/core/int_literals.wast:71
+assert_malformed(() => instantiate(`(global i32 (i32.const _100)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:75
+assert_malformed(() => instantiate(`(global i32 (i32.const +_100)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:79
+assert_malformed(() => instantiate(`(global i32 (i32.const -_100)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:83
+assert_malformed(() => instantiate(`(global i32 (i32.const 99_)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:87
+assert_malformed(
+  () => instantiate(`(global i32 (i32.const 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:91
+assert_malformed(
+  () => instantiate(`(global i32 (i32.const _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:95
+assert_malformed(
+  () => instantiate(`(global i32 (i32.const 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:99
+assert_malformed(
+  () => instantiate(`(global i32 (i32.const 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:103
+assert_malformed(() => instantiate(`(global i32 (i32.const 0x00_)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:107
+assert_malformed(
+  () => instantiate(`(global i32 (i32.const 0xff__ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:112
+assert_malformed(() => instantiate(`(global i64 (i64.const _100)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:116
+assert_malformed(() => instantiate(`(global i64 (i64.const +_100)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:120
+assert_malformed(() => instantiate(`(global i64 (i64.const -_100)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:124
+assert_malformed(() => instantiate(`(global i64 (i64.const 99_)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:128
+assert_malformed(
+  () => instantiate(`(global i64 (i64.const 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:132
+assert_malformed(
+  () => instantiate(`(global i64 (i64.const _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:136
+assert_malformed(
+  () => instantiate(`(global i64 (i64.const 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:140
+assert_malformed(
+  () => instantiate(`(global i64 (i64.const 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/int_literals.wast:144
+assert_malformed(() => instantiate(`(global i64 (i64.const 0x00_)) `), `unknown operator`);
+
+// ./test/core/int_literals.wast:148
+assert_malformed(
+  () => instantiate(`(global i64 (i64.const 0xff__ffff)) `),
+  `unknown operator`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/labels.wast.js b/js/src/jit-test/tests/wasm/spec/spec/labels.wast.js
new file mode 100644
index 0000000000..b76f13f90a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/labels.wast.js
@@ -0,0 +1,400 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/labels.wast
+
+// ./test/core/labels.wast:1
+let $0 = instantiate(`(module
+  (func (export "block") (result i32)
+    (block $$exit (result i32)
+      (br $$exit (i32.const 1))
+      (i32.const 0)
+    )
+  )
+
+  (func (export "loop1") (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 0))
+    (block $$exit (result i32)
+      (loop $$cont (result i32)
+        (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+        (if (i32.eq (local.get $$i) (i32.const 5))
+          (then (br $$exit (local.get $$i)))
+        )
+        (br $$cont)
+      )
+    )
+  )
+
+  (func (export "loop2") (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 0))
+    (block $$exit (result i32)
+      (loop $$cont (result i32)
+        (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+        (if (i32.eq (local.get $$i) (i32.const 5))
+          (then (br $$cont))
+        )
+        (if (i32.eq (local.get $$i) (i32.const 8))
+          (then (br $$exit (local.get $$i)))
+        )
+        (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+        (br $$cont)
+      )
+    )
+  )
+
+  (func (export "loop3") (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 0))
+    (block $$exit (result i32)
+      (loop $$cont (result i32)
+        (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+        (if (i32.eq (local.get $$i) (i32.const 5))
+          (then (br $$exit (local.get $$i)))
+        )
+        (local.get $$i)
+      )
+    )
+  )
+
+  (func (export "loop4") (param $$max i32) (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 1))
+    (block $$exit (result i32)
+      (loop $$cont (result i32)
+        (local.set $$i (i32.add (local.get $$i) (local.get $$i)))
+        (if (i32.gt_u (local.get $$i) (local.get $$max))
+          (then (br $$exit (local.get $$i)))
+        )
+        (br $$cont)
+      )
+    )
+  )
+
+  (func (export "loop5") (result i32)
+    (i32.add
+      (loop $$l (result i32) (i32.const 1))
+      (i32.const 1)
+    )
+  )
+
+  (func (export "loop6") (result i32)
+    (loop (result i32)
+      (br_if 0 (i32.const 0))
+      (i32.const 3)
+    )
+  )
+
+  (func (export "if") (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 0))
+    (block
+      (if $$l
+        (i32.const 1)
+        (then (br $$l) (local.set $$i (i32.const 666)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if $$l
+        (i32.const 1)
+        (then (br $$l) (local.set $$i (i32.const 666)))
+        (else (local.set $$i (i32.const 888)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if $$l
+        (i32.const 1)
+        (then (br $$l) (local.set $$i (i32.const 666)))
+        (else (local.set $$i (i32.const 888)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if $$l
+        (i32.const 0)
+        (then (local.set $$i (i32.const 888)))
+        (else (br $$l) (local.set $$i (i32.const 666)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if $$l
+        (i32.const 0)
+        (then (local.set $$i (i32.const 888)))
+        (else (br $$l) (local.set $$i (i32.const 666)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+    )
+    (local.get $$i)
+  )
+
+  (func (export "if2") (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 0))
+    (block
+      (if
+        (i32.const 1)
+        (then (br 0) (local.set $$i (i32.const 666)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if
+        (i32.const 1)
+        (then (br 0) (local.set $$i (i32.const 666)))
+        (else (local.set $$i (i32.const 888)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if
+        (i32.const 1)
+        (then (br 0) (local.set $$i (i32.const 666)))
+        (else (local.set $$i (i32.const 888)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if
+        (i32.const 0)
+        (then (local.set $$i (i32.const 888)))
+        (else (br 0) (local.set $$i (i32.const 666)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+      (if
+        (i32.const 0)
+        (then (local.set $$i (i32.const 888)))
+        (else (br 0) (local.set $$i (i32.const 666)))
+      )
+      (local.set $$i (i32.add (local.get $$i) (i32.const 1)))
+    )
+    (local.get $$i)
+  )
+
+  (func (export "switch") (param i32) (result i32)
+    (block $$ret (result i32)
+      (i32.mul (i32.const 10)
+        (block $$exit (result i32)
+          (block $$0
+            (block $$default
+              (block $$3
+                (block $$2
+                  (block $$1
+                    (br_table $$0 $$1 $$2 $$3 $$default (local.get 0))
+                  ) ;; 1
+                ) ;; 2
+                (br $$exit (i32.const 2))
+              ) ;; 3
+              (br $$ret (i32.const 3))
+            ) ;; default
+          ) ;; 0
+          (i32.const 5)
+        )
+      )
+    )
+  )
+
+  (func (export "return") (param i32) (result i32)
+    (block $$default
+      (block $$1
+        (block $$0
+          (br_table $$0 $$1 (local.get 0))
+          (br $$default)
+        ) ;; 0
+        (return (i32.const 0))
+      ) ;; 1
+    ) ;; default
+    (i32.const 2)
+  )
+
+  (func (export "br_if0") (result i32)
+    (local $$i i32)
+    (local.set $$i (i32.const 0))
+    (block $$outer (result i32)
+      (block $$inner
+        (br_if $$inner (i32.const 0))
+        (local.set $$i (i32.or (local.get $$i) (i32.const 0x1)))
+        (br_if $$inner (i32.const 1))
+        (local.set $$i (i32.or (local.get $$i) (i32.const 0x2)))
+      )
+      (drop (br_if $$outer
+        (block (result i32)
+          (local.set $$i (i32.or (local.get $$i) (i32.const 0x4)))
+          (local.get $$i)
+        )
+        (i32.const 0)
+      ))
+      (local.set $$i (i32.or (local.get $$i) (i32.const 0x8)))
+      (drop (br_if $$outer
+        (block (result i32)
+          (local.set $$i (i32.or (local.get $$i) (i32.const 0x10)))
+          (local.get $$i)
+        )
+        (i32.const 1)
+      ))
+      (local.set $$i (i32.or (local.get $$i) (i32.const 0x20))) (local.get $$i)
+    )
+  )
+
+  (func (export "br_if1") (result i32)
+    (block $$l0 (result i32)
+      (drop
+        (br_if $$l0
+          (block $$l1 (result i32) (br $$l1 (i32.const 1)))
+          (i32.const 1)
+        )
+      )
+      (i32.const 0)
+    )
+  )
+
+  (func (export "br_if2") (result i32)
+    (block $$l0 (result i32)
+      (if (i32.const 1)
+        (then
+          (drop
+            (br_if $$l0
+              (block $$l1 (result i32) (br $$l1 (i32.const 1)))
+              (i32.const 1)
+            )
+          )
+        )
+      )
+      (i32.const 0)
+    )
+  )
+
+  (func (export "br_if3") (result i32)
+    (local $$i1 i32)
+    (drop
+      (i32.add
+        (block $$l0 (result i32)
+          (drop (br_if $$l0
+            (block (result i32) (local.set $$i1 (i32.const 1)) (local.get $$i1))
+            (block (result i32) (local.set $$i1 (i32.const 2)) (local.get $$i1))
+          ))
+          (i32.const 0)
+        )
+        (i32.const 0)
+      )
+    )
+    (local.get $$i1)
+  )
+
+  (func (export "br") (result i32)
+    (block $$l0 (result i32)
+      (if (i32.const 1)
+        (then (br $$l0 (block $$l1 (result i32) (br $$l1 (i32.const 1)))))
+        (else (block (drop (block $$l1 (result i32) (br $$l1 (i32.const 1))))))
+      )
+      (i32.const 1)
+    )
+  )
+
+  (func (export "shadowing") (result i32)
+    (block $$l1 (result i32) (i32.xor (br $$l1 (i32.const 1)) (i32.const 2)))
+  )
+
+  (func (export "redefinition") (result i32)
+    (block $$l1 (result i32)
+      (i32.add
+        (block $$l1 (result i32) (i32.const 2))
+        (block $$l1 (result i32) (br $$l1 (i32.const 3)))
+      )
+    )
+  )
+)`);
+
+// ./test/core/labels.wast:291
+assert_return(() => invoke($0, `block`, []), [value("i32", 1)]);
+
+// ./test/core/labels.wast:292
+assert_return(() => invoke($0, `loop1`, []), [value("i32", 5)]);
+
+// ./test/core/labels.wast:293
+assert_return(() => invoke($0, `loop2`, []), [value("i32", 8)]);
+
+// ./test/core/labels.wast:294
+assert_return(() => invoke($0, `loop3`, []), [value("i32", 1)]);
+
+// ./test/core/labels.wast:295
+assert_return(() => invoke($0, `loop4`, [8]), [value("i32", 16)]);
+
+// ./test/core/labels.wast:296
+assert_return(() => invoke($0, `loop5`, []), [value("i32", 2)]);
+
+// ./test/core/labels.wast:297
+assert_return(() => invoke($0, `loop6`, []), [value("i32", 3)]);
+
+// ./test/core/labels.wast:298
+assert_return(() => invoke($0, `if`, []), [value("i32", 5)]);
+
+// ./test/core/labels.wast:299
+assert_return(() => invoke($0, `if2`, []), [value("i32", 5)]);
+
+// ./test/core/labels.wast:300
+assert_return(() => invoke($0, `switch`, [0]), [value("i32", 50)]);
+
+// ./test/core/labels.wast:301
+assert_return(() => invoke($0, `switch`, [1]), [value("i32", 20)]);
+
+// ./test/core/labels.wast:302
+assert_return(() => invoke($0, `switch`, [2]), [value("i32", 20)]);
+
+// ./test/core/labels.wast:303
+assert_return(() => invoke($0, `switch`, [3]), [value("i32", 3)]);
+
+// ./test/core/labels.wast:304
+assert_return(() => invoke($0, `switch`, [4]), [value("i32", 50)]);
+
+// ./test/core/labels.wast:305
+assert_return(() => invoke($0, `switch`, [5]), [value("i32", 50)]);
+
+// ./test/core/labels.wast:306
+assert_return(() => invoke($0, `return`, [0]), [value("i32", 0)]);
+
+// ./test/core/labels.wast:307
+assert_return(() => invoke($0, `return`, [1]), [value("i32", 2)]);
+
+// ./test/core/labels.wast:308
+assert_return(() => invoke($0, `return`, [2]), [value("i32", 2)]);
+
+// ./test/core/labels.wast:309
+assert_return(() => invoke($0, `br_if0`, []), [value("i32", 29)]);
+
+// ./test/core/labels.wast:310
+assert_return(() => invoke($0, `br_if1`, []), [value("i32", 1)]);
+
+// ./test/core/labels.wast:311
+assert_return(() => invoke($0, `br_if2`, []), [value("i32", 1)]);
+
+// ./test/core/labels.wast:312
+assert_return(() => invoke($0, `br_if3`, []), [value("i32", 2)]);
+
+// ./test/core/labels.wast:313
+assert_return(() => invoke($0, `br`, []), [value("i32", 1)]);
+
+// ./test/core/labels.wast:314
+assert_return(() => invoke($0, `shadowing`, []), [value("i32", 1)]);
+
+// ./test/core/labels.wast:315
+assert_return(() => invoke($0, `redefinition`, []), [value("i32", 5)]);
+
+// ./test/core/labels.wast:317
+assert_invalid(
+  () => instantiate(`(module (func (block $$l (f32.neg (br_if $$l (i32.const 1))) (nop))))`),
+  `type mismatch`,
+);
+
+// ./test/core/labels.wast:321
+assert_invalid(
+  () => instantiate(`(module (func (block $$l (br_if $$l (f32.const 0) (i32.const 1)))))`),
+  `type mismatch`,
+);
+
+// ./test/core/labels.wast:325
+assert_invalid(
+  () => instantiate(`(module (func (block $$l (br_if $$l (f32.const 0) (i32.const 1)))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/left-to-right.wast.js b/js/src/jit-test/tests/wasm/spec/spec/left-to-right.wast.js
new file mode 100644
index 0000000000..9e1f168906
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/left-to-right.wast.js
@@ -0,0 +1,482 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/left-to-right.wast
+
+// ./test/core/left-to-right.wast:1
+let $0 = instantiate(`(module
+  (memory 1)
+
+  (type $$i32_T (func (param i32 i32) (result i32)))
+  (type $$i64_T (func (param i64 i64) (result i32)))
+  (type $$f32_T (func (param f32 f32) (result i32)))
+  (type $$f64_T (func (param f64 f64) (result i32)))
+  (table funcref
+    (elem $$i32_t0 $$i32_t1 $$i64_t0 $$i64_t1 $$f32_t0 $$f32_t1 $$f64_t0 $$f64_t1)
+  )
+
+  (func $$i32_t0 (type $$i32_T) (i32.const -1))
+  (func $$i32_t1 (type $$i32_T) (i32.const -2))
+  (func $$i64_t0 (type $$i64_T) (i32.const -1))
+  (func $$i64_t1 (type $$i64_T) (i32.const -2))
+  (func $$f32_t0 (type $$f32_T) (i32.const -1))
+  (func $$f32_t1 (type $$f32_T) (i32.const -2))
+  (func $$f64_t0 (type $$f64_T) (i32.const -1))
+  (func $$f64_t1 (type $$f64_T) (i32.const -2))
+
+  ;; The idea is: We reset the memory, then the instruction call $$*_left,
+  ;; $$*_right, $$*_another, $$*_callee (for indirect calls), and $$*_bool (when a
+  ;; boolean value is needed). These functions all call bump, which shifts the
+  ;; memory starting at address 8 up a byte, and then store a unique value at
+  ;; address 8. Then we read the 4-byte value at address 8. It should contain
+  ;; the correct sequence of unique values if the calls were evaluated in the
+  ;; correct order.
+
+  (func $$reset (i32.store (i32.const 8) (i32.const 0)))
+
+  (func $$bump
+    (i32.store8 (i32.const 11) (i32.load8_u (i32.const 10)))
+    (i32.store8 (i32.const 10) (i32.load8_u (i32.const 9)))
+    (i32.store8 (i32.const 9) (i32.load8_u (i32.const 8)))
+    (i32.store8 (i32.const 8) (i32.const -3)))
+
+  (func $$get (result i32) (i32.load (i32.const 8)))
+
+  (func $$i32_left (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 1)) (i32.const 0))
+  (func $$i32_right (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 2)) (i32.const 1))
+  (func $$i32_another (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 3)) (i32.const 1))
+  (func $$i32_callee (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 0))
+  (func $$i32_bool (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $$i64_left (result i64) (call $$bump) (i32.store8 (i32.const 8) (i32.const 1)) (i64.const 0))
+  (func $$i64_right (result i64) (call $$bump) (i32.store8 (i32.const 8) (i32.const 2)) (i64.const 1))
+  (func $$i64_another (result i64) (call $$bump) (i32.store8 (i32.const 8) (i32.const 3)) (i64.const 1))
+  (func $$i64_callee (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 2))
+  (func $$i64_bool (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $$f32_left (result f32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 1)) (f32.const 0))
+  (func $$f32_right (result f32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 2)) (f32.const 1))
+  (func $$f32_another (result f32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 3)) (f32.const 1))
+  (func $$f32_callee (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 4))
+  (func $$f32_bool (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $$f64_left (result f64) (call $$bump) (i32.store8 (i32.const 8) (i32.const 1)) (f64.const 0))
+  (func $$f64_right (result f64) (call $$bump) (i32.store8 (i32.const 8) (i32.const 2)) (f64.const 1))
+  (func $$f64_another (result f64) (call $$bump) (i32.store8 (i32.const 8) (i32.const 3)) (f64.const 1))
+  (func $$f64_callee (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 6))
+  (func $$f64_bool (result i32) (call $$bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $$i32_dummy (param i32 i32))
+  (func $$i64_dummy (param i64 i64))
+  (func $$f32_dummy (param f32 f32))
+  (func $$f64_dummy (param f64 f64))
+
+  (func (export "i32_add") (result i32) (call $$reset) (drop (i32.add (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_sub") (result i32) (call $$reset) (drop (i32.sub (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_mul") (result i32) (call $$reset) (drop (i32.mul (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_div_s") (result i32) (call $$reset) (drop (i32.div_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_div_u") (result i32) (call $$reset) (drop (i32.div_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_rem_s") (result i32) (call $$reset) (drop (i32.rem_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_rem_u") (result i32) (call $$reset) (drop (i32.rem_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_and") (result i32) (call $$reset) (drop (i32.and (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_or") (result i32) (call $$reset) (drop (i32.or (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_xor") (result i32) (call $$reset) (drop (i32.xor (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_shl") (result i32) (call $$reset) (drop (i32.shl (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_shr_u") (result i32) (call $$reset) (drop (i32.shr_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_shr_s") (result i32) (call $$reset) (drop (i32.shr_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_eq") (result i32) (call $$reset) (drop (i32.eq (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_ne") (result i32) (call $$reset) (drop (i32.ne (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_lt_s") (result i32) (call $$reset) (drop (i32.lt_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_le_s") (result i32) (call $$reset) (drop (i32.le_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_lt_u") (result i32) (call $$reset) (drop (i32.lt_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_le_u") (result i32) (call $$reset) (drop (i32.le_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_gt_s") (result i32) (call $$reset) (drop (i32.gt_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_ge_s") (result i32) (call $$reset) (drop (i32.ge_s (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_gt_u") (result i32) (call $$reset) (drop (i32.gt_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_ge_u") (result i32) (call $$reset) (drop (i32.ge_u (call $$i32_left) (call $$i32_right))) (call $$get))
+  (func (export "i32_store") (result i32) (call $$reset) (i32.store (call $$i32_left) (call $$i32_right)) (call $$get))
+  (func (export "i32_store8") (result i32) (call $$reset) (i32.store8 (call $$i32_left) (call $$i32_right)) (call $$get))
+  (func (export "i32_store16") (result i32) (call $$reset) (i32.store16 (call $$i32_left) (call $$i32_right)) (call $$get))
+  (func (export "i32_call") (result i32) (call $$reset) (call $$i32_dummy (call $$i32_left) (call $$i32_right)) (call $$get))
+  (func (export "i32_call_indirect") (result i32) (call $$reset) (drop (call_indirect (type $$i32_T) (call $$i32_left) (call $$i32_right) (call $$i32_callee))) (call $$get))
+  (func (export "i32_select") (result i32) (call $$reset) (drop (select (call $$i32_left) (call $$i32_right) (call $$i32_bool))) (call $$get))
+
+  (func (export "i64_add") (result i32) (call $$reset) (drop (i64.add (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_sub") (result i32) (call $$reset) (drop (i64.sub (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_mul") (result i32) (call $$reset) (drop (i64.mul (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_div_s") (result i32) (call $$reset) (drop (i64.div_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_div_u") (result i32) (call $$reset) (drop (i64.div_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_rem_s") (result i32) (call $$reset) (drop (i64.rem_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_rem_u") (result i32) (call $$reset) (drop (i64.rem_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_and") (result i32) (call $$reset) (drop (i64.and (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_or") (result i32) (call $$reset) (drop (i64.or (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_xor") (result i32) (call $$reset) (drop (i64.xor (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_shl") (result i32) (call $$reset) (drop (i64.shl (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_shr_u") (result i32) (call $$reset) (drop (i64.shr_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_shr_s") (result i32) (call $$reset) (drop (i64.shr_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_eq") (result i32) (call $$reset) (drop (i64.eq (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_ne") (result i32) (call $$reset) (drop (i64.ne (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_lt_s") (result i32) (call $$reset) (drop (i64.lt_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_le_s") (result i32) (call $$reset) (drop (i64.le_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_lt_u") (result i32) (call $$reset) (drop (i64.lt_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_le_u") (result i32) (call $$reset) (drop (i64.le_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_gt_s") (result i32) (call $$reset) (drop (i64.gt_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_ge_s") (result i32) (call $$reset) (drop (i64.ge_s (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_gt_u") (result i32) (call $$reset) (drop (i64.gt_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_ge_u") (result i32) (call $$reset) (drop (i64.ge_u (call $$i64_left) (call $$i64_right))) (call $$get))
+  (func (export "i64_store") (result i32) (call $$reset) (i64.store (call $$i32_left) (call $$i64_right)) (call $$get))
+  (func (export "i64_store8") (result i32) (call $$reset) (i64.store8 (call $$i32_left) (call $$i64_right)) (call $$get))
+  (func (export "i64_store16") (result i32) (call $$reset) (i64.store16 (call $$i32_left) (call $$i64_right)) (call $$get))
+  (func (export "i64_store32") (result i32) (call $$reset) (i64.store32 (call $$i32_left) (call $$i64_right)) (call $$get))
+  (func (export "i64_call") (result i32) (call $$reset) (call $$i64_dummy (call $$i64_left) (call $$i64_right)) (call $$get))
+  (func (export "i64_call_indirect") (result i32) (call $$reset) (drop (call_indirect (type $$i64_T) (call $$i64_left) (call $$i64_right) (call $$i64_callee))) (call $$get))
+  (func (export "i64_select") (result i32) (call $$reset) (drop (select (call $$i64_left) (call $$i64_right) (call $$i64_bool))) (call $$get))
+
+  (func (export "f32_add") (result i32) (call $$reset) (drop (f32.add (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_sub") (result i32) (call $$reset) (drop (f32.sub (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_mul") (result i32) (call $$reset) (drop (f32.mul (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_div") (result i32) (call $$reset) (drop (f32.div (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_copysign") (result i32) (call $$reset) (drop (f32.copysign (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_eq") (result i32) (call $$reset) (drop (f32.eq (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_ne") (result i32) (call $$reset) (drop (f32.ne (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_lt") (result i32) (call $$reset) (drop (f32.lt (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_le") (result i32) (call $$reset) (drop (f32.le (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_gt") (result i32) (call $$reset) (drop (f32.gt (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_ge") (result i32) (call $$reset) (drop (f32.ge (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_min") (result i32) (call $$reset) (drop (f32.min (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_max") (result i32) (call $$reset) (drop (f32.max (call $$f32_left) (call $$f32_right))) (call $$get))
+  (func (export "f32_store") (result i32) (call $$reset) (f32.store (call $$i32_left) (call $$f32_right)) (call $$get))
+  (func (export "f32_call") (result i32) (call $$reset) (call $$f32_dummy (call $$f32_left) (call $$f32_right)) (call $$get))
+  (func (export "f32_call_indirect") (result i32) (call $$reset) (drop (call_indirect (type $$f32_T) (call $$f32_left) (call $$f32_right) (call $$f32_callee))) (call $$get))
+  (func (export "f32_select") (result i32) (call $$reset) (drop (select (call $$f32_left) (call $$f32_right) (call $$f32_bool))) (call $$get))
+
+  (func (export "f64_add") (result i32) (call $$reset) (drop (f64.add (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_sub") (result i32) (call $$reset) (drop (f64.sub (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_mul") (result i32) (call $$reset) (drop (f64.mul (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_div") (result i32) (call $$reset) (drop (f64.div (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_copysign") (result i32) (call $$reset) (drop (f64.copysign (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_eq") (result i32) (call $$reset) (drop (f64.eq (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_ne") (result i32) (call $$reset) (drop (f64.ne (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_lt") (result i32) (call $$reset) (drop (f64.lt (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_le") (result i32) (call $$reset) (drop (f64.le (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_gt") (result i32) (call $$reset) (drop (f64.gt (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_ge") (result i32) (call $$reset) (drop (f64.ge (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_min") (result i32) (call $$reset) (drop (f64.min (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_max") (result i32) (call $$reset) (drop (f64.max (call $$f64_left) (call $$f64_right))) (call $$get))
+  (func (export "f64_store") (result i32) (call $$reset) (f64.store (call $$i32_left) (call $$f64_right)) (call $$get))
+  (func (export "f64_call") (result i32) (call $$reset) (call $$f64_dummy (call $$f64_left) (call $$f64_right)) (call $$get))
+  (func (export "f64_call_indirect") (result i32) (call $$reset) (drop (call_indirect (type $$f64_T) (call $$f64_left) (call $$f64_right) (call $$f64_callee))) (call $$get))
+  (func (export "f64_select") (result i32) (call $$reset) (drop (select (call $$f64_left) (call $$f64_right) (call $$f64_bool))) (call $$get))
+
+  (func (export "br_if") (result i32)
+    (block (result i32)
+      (call $$reset)
+      (drop (br_if 0 (call $$i32_left) (i32.and (call $$i32_right) (i32.const 0))))
+      (call $$get)
+    )
+  )
+  (func (export "br_table") (result i32)
+    (block $$a (result i32)
+      (call $$reset)
+      (drop
+        (block $$b (result i32)
+          (br_table $$a $$b (call $$i32_left) (call $$i32_right))
+        )
+      )
+      (call $$get)
+    )
+  )
+)`);
+
+// ./test/core/left-to-right.wast:181
+assert_return(() => invoke($0, `i32_add`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:181:59
+assert_return(() => invoke($0, `i64_add`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:182
+assert_return(() => invoke($0, `i32_sub`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:182:59
+assert_return(() => invoke($0, `i64_sub`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:183
+assert_return(() => invoke($0, `i32_mul`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:183:59
+assert_return(() => invoke($0, `i64_mul`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:184
+assert_return(() => invoke($0, `i32_div_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:184:59
+assert_return(() => invoke($0, `i64_div_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:185
+assert_return(() => invoke($0, `i32_div_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:185:59
+assert_return(() => invoke($0, `i64_div_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:186
+assert_return(() => invoke($0, `i32_rem_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:186:59
+assert_return(() => invoke($0, `i64_rem_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:187
+assert_return(() => invoke($0, `i32_rem_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:187:59
+assert_return(() => invoke($0, `i64_rem_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:188
+assert_return(() => invoke($0, `i32_and`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:188:59
+assert_return(() => invoke($0, `i64_and`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:189
+assert_return(() => invoke($0, `i32_or`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:189:59
+assert_return(() => invoke($0, `i64_or`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:190
+assert_return(() => invoke($0, `i32_xor`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:190:59
+assert_return(() => invoke($0, `i64_xor`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:191
+assert_return(() => invoke($0, `i32_shl`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:191:59
+assert_return(() => invoke($0, `i64_shl`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:192
+assert_return(() => invoke($0, `i32_shr_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:192:59
+assert_return(() => invoke($0, `i64_shr_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:193
+assert_return(() => invoke($0, `i32_shr_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:193:59
+assert_return(() => invoke($0, `i64_shr_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:194
+assert_return(() => invoke($0, `i32_eq`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:194:59
+assert_return(() => invoke($0, `i64_eq`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:195
+assert_return(() => invoke($0, `i32_ne`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:195:59
+assert_return(() => invoke($0, `i64_ne`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:196
+assert_return(() => invoke($0, `i32_lt_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:196:59
+assert_return(() => invoke($0, `i64_lt_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:197
+assert_return(() => invoke($0, `i32_le_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:197:59
+assert_return(() => invoke($0, `i64_le_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:198
+assert_return(() => invoke($0, `i32_lt_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:198:59
+assert_return(() => invoke($0, `i64_lt_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:199
+assert_return(() => invoke($0, `i32_le_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:199:59
+assert_return(() => invoke($0, `i64_le_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:200
+assert_return(() => invoke($0, `i32_gt_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:200:59
+assert_return(() => invoke($0, `i64_gt_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:201
+assert_return(() => invoke($0, `i32_ge_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:201:59
+assert_return(() => invoke($0, `i64_ge_s`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:202
+assert_return(() => invoke($0, `i32_gt_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:202:59
+assert_return(() => invoke($0, `i64_gt_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:203
+assert_return(() => invoke($0, `i32_ge_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:203:59
+assert_return(() => invoke($0, `i64_ge_u`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:204
+assert_return(() => invoke($0, `i32_store`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:204:59
+assert_return(() => invoke($0, `i64_store`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:205
+assert_return(() => invoke($0, `i32_store8`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:205:59
+assert_return(() => invoke($0, `i64_store8`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:206
+assert_return(() => invoke($0, `i32_store16`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:206:59
+assert_return(() => invoke($0, `i64_store16`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:207
+assert_return(() => invoke($0, `i64_store32`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:208
+assert_return(() => invoke($0, `i32_call`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:208:59
+assert_return(() => invoke($0, `i64_call`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:209
+assert_return(() => invoke($0, `i32_call_indirect`, []), [value("i32", 66052)]);
+
+// ./test/core/left-to-right.wast:210
+assert_return(() => invoke($0, `i64_call_indirect`, []), [value("i32", 66052)]);
+
+// ./test/core/left-to-right.wast:211
+assert_return(() => invoke($0, `i32_select`, []), [value("i32", 66053)]);
+
+// ./test/core/left-to-right.wast:211:61
+assert_return(() => invoke($0, `i64_select`, []), [value("i32", 66053)]);
+
+// ./test/core/left-to-right.wast:213
+assert_return(() => invoke($0, `f32_add`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:213:59
+assert_return(() => invoke($0, `f64_add`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:214
+assert_return(() => invoke($0, `f32_sub`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:214:59
+assert_return(() => invoke($0, `f64_sub`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:215
+assert_return(() => invoke($0, `f32_mul`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:215:59
+assert_return(() => invoke($0, `f64_mul`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:216
+assert_return(() => invoke($0, `f32_div`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:216:59
+assert_return(() => invoke($0, `f64_div`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:217
+assert_return(() => invoke($0, `f32_copysign`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:217:59
+assert_return(() => invoke($0, `f64_copysign`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:218
+assert_return(() => invoke($0, `f32_eq`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:218:59
+assert_return(() => invoke($0, `f64_eq`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:219
+assert_return(() => invoke($0, `f32_ne`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:219:59
+assert_return(() => invoke($0, `f64_ne`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:220
+assert_return(() => invoke($0, `f32_lt`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:220:59
+assert_return(() => invoke($0, `f64_lt`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:221
+assert_return(() => invoke($0, `f32_le`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:221:59
+assert_return(() => invoke($0, `f64_le`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:222
+assert_return(() => invoke($0, `f32_gt`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:222:59
+assert_return(() => invoke($0, `f64_gt`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:223
+assert_return(() => invoke($0, `f32_ge`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:223:59
+assert_return(() => invoke($0, `f64_ge`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:224
+assert_return(() => invoke($0, `f32_min`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:224:59
+assert_return(() => invoke($0, `f64_min`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:225
+assert_return(() => invoke($0, `f32_max`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:225:59
+assert_return(() => invoke($0, `f64_max`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:226
+assert_return(() => invoke($0, `f32_store`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:226:59
+assert_return(() => invoke($0, `f64_store`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:227
+assert_return(() => invoke($0, `f32_call`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:227:59
+assert_return(() => invoke($0, `f64_call`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:228
+assert_return(() => invoke($0, `f32_call_indirect`, []), [value("i32", 66052)]);
+
+// ./test/core/left-to-right.wast:229
+assert_return(() => invoke($0, `f64_call_indirect`, []), [value("i32", 66052)]);
+
+// ./test/core/left-to-right.wast:230
+assert_return(() => invoke($0, `f32_select`, []), [value("i32", 66053)]);
+
+// ./test/core/left-to-right.wast:230:61
+assert_return(() => invoke($0, `f64_select`, []), [value("i32", 66053)]);
+
+// ./test/core/left-to-right.wast:232
+assert_return(() => invoke($0, `br_if`, []), [value("i32", 258)]);
+
+// ./test/core/left-to-right.wast:233
+assert_return(() => invoke($0, `br_table`, []), [value("i32", 258)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/load.wast.js b/js/src/jit-test/tests/wasm/spec/spec/load.wast.js
new file mode 100644
index 0000000000..55b00e573e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/load.wast.js
@@ -0,0 +1,749 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/load.wast
+
+// ./test/core/load.wast:3
+let $0 = instantiate(`(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.load (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (i32.load (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i32.load (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (i32.load (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (i32.load (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.load (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (i32.load (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (i32.load (i32.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (i32.load (i32.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (i32.load (i32.const 0)))
+  )
+
+  (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $$f (i32.load (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $$f (i32.const 1) (i32.load (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $$f (i32.const 1) (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (type $$sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $$sig)
+      (i32.load (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.load (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (i32.load (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (i32.load (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (i32.load (i32.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (i32.load (i32.const 0)))
+  )
+  (global $$g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $$g (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (i32.load (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (i32.load (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (i32.load8_s (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (i32.load (i32.const 100)))
+  )
+)`);
+
+// ./test/core/load.wast:161
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:163
+assert_return(() => invoke($0, `as-br_if-cond`, []), []);
+
+// ./test/core/load.wast:164
+assert_return(() => invoke($0, `as-br_if-value`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:165
+assert_return(() => invoke($0, `as-br_if-value-cond`, []), [value("i32", 7)]);
+
+// ./test/core/load.wast:167
+assert_return(() => invoke($0, `as-br_table-index`, []), []);
+
+// ./test/core/load.wast:168
+assert_return(() => invoke($0, `as-br_table-value`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:169
+assert_return(() => invoke($0, `as-br_table-value-index`, []), [value("i32", 6)]);
+
+// ./test/core/load.wast:171
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:173
+assert_return(() => invoke($0, `as-if-cond`, []), [value("i32", 1)]);
+
+// ./test/core/load.wast:174
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:175
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:177
+assert_return(() => invoke($0, `as-select-first`, [0, 1]), [value("i32", 0)]);
+
+// ./test/core/load.wast:178
+assert_return(() => invoke($0, `as-select-second`, [0, 0]), [value("i32", 0)]);
+
+// ./test/core/load.wast:179
+assert_return(() => invoke($0, `as-select-cond`, []), [value("i32", 1)]);
+
+// ./test/core/load.wast:181
+assert_return(() => invoke($0, `as-call-first`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:182
+assert_return(() => invoke($0, `as-call-mid`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:183
+assert_return(() => invoke($0, `as-call-last`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:185
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:186
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:187
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:188
+assert_return(() => invoke($0, `as-call_indirect-index`, []), [value("i32", -1)]);
+
+// ./test/core/load.wast:190
+assert_return(() => invoke($0, `as-local.set-value`, []), []);
+
+// ./test/core/load.wast:191
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:192
+assert_return(() => invoke($0, `as-global.set-value`, []), []);
+
+// ./test/core/load.wast:194
+assert_return(() => invoke($0, `as-load-address`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:195
+assert_return(() => invoke($0, `as-loadN-address`, []), [value("i32", 0)]);
+
+// ./test/core/load.wast:196
+assert_return(() => invoke($0, `as-store-address`, []), []);
+
+// ./test/core/load.wast:197
+assert_return(() => invoke($0, `as-store-value`, []), []);
+
+// ./test/core/load.wast:198
+assert_return(() => invoke($0, `as-storeN-address`, []), []);
+
+// ./test/core/load.wast:199
+assert_return(() => invoke($0, `as-storeN-value`, []), []);
+
+// ./test/core/load.wast:201
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 32)]);
+
+// ./test/core/load.wast:203
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 10)]);
+
+// ./test/core/load.wast:204
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i32", 10)]);
+
+// ./test/core/load.wast:206
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 1)]);
+
+// ./test/core/load.wast:208
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/load.wast:209
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/load.wast:211
+assert_return(() => invoke($0, `as-memory.grow-size`, []), [value("i32", 1)]);
+
+// ./test/core/load.wast:213
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i32) (i32.load32 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:220
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i32) (i32.load32_u (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:227
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i32) (i32.load32_s (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:234
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i32) (i32.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:241
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i32) (i32.load64_u (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:248
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i32) (i32.load64_s (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:256
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i64) (i64.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:263
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i64) (i64.load64_u (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:270
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result i64) (i64.load64_s (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:278
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result f32) (f32.load32 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:285
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result f32) (f32.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:293
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result f64) (f64.load32 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:300
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (result f64) (f64.load64 (local.get 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/load.wast:311
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load_i32 (i32.load (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:315
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load8_s_i32 (i32.load8_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:319
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load8_u_i32 (i32.load8_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:323
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load16_s_i32 (i32.load16_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:327
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load16_u_i32 (i32.load16_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:331
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load_i64 (i64.load (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:335
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load8_s_i64 (i64.load8_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:339
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load8_u_i64 (i64.load8_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:343
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load16_s_i64 (i64.load16_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:347
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load16_u_i64 (i64.load16_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:351
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load32_s_i64 (i64.load32_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:355
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load32_u_i64 (i64.load32_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:359
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load_f32 (f32.load (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:363
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func $$load_f64 (f64.load (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:371
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i32) (i32.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:372
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i32) (i32.load8_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:373
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i32) (i32.load8_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:374
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i32) (i32.load16_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:375
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i32) (i32.load16_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:376
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:377
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load8_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:378
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load8_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:379
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load16_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:380
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load16_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:381
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load32_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:382
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result i64) (i64.load32_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:383
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result f32) (f32.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:384
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result f64) (f64.load (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:387
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty
+      (i32.load) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:396
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-block
+      (i32.const 0)
+      (block (i32.load) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:406
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-loop
+      (i32.const 0)
+      (loop (i32.load) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:416
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.load) (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:426
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.load))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:436
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.load)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:446
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.load) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:456
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.load)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:466
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-return
+      (return (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:475
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-select
+      (select (i32.load) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:484
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-call
+      (call 1 (i32.load)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:494
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-address-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.load) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:511
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.load)) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:521
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:531
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-address-empty-in-global.set
+      (global.set $$x (i32.load)) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:541
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-memory.grow
+      (memory.grow (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:550
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-address-empty-in-load
+      (i32.load (i32.load)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/load.wast:559
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-store
+      (i32.store (i32.load) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/local_get.wast.js b/js/src/jit-test/tests/wasm/spec/spec/local_get.wast.js
new file mode 100644
index 0000000000..c51b00bd31
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/local_get.wast.js
@@ -0,0 +1,279 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/local_get.wast
+
+// ./test/core/local_get.wast:3
+let $0 = instantiate(`(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "type-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "type-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "type-local-f64") (result f64) (local f64) (local.get 0))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.get 0))
+  (func (export "type-param-i64") (param i64) (result i64) (local.get 0))
+  (func (export "type-param-f32") (param f32) (result f32) (local.get 0))
+  (func (export "type-param-f64") (param f64) (result f64) (local.get 0))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32)
+    (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.get 0)))
+    (drop (f32.neg (local.get 1)))
+    (drop (f64.neg (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (i32.eqz (local.get 4)))
+    (drop (f32.neg (local.get 5)))
+    (drop (i64.eqz (local.get 6)))
+    (drop (i64.eqz (local.get 7)))
+    (drop (f64.neg (local.get 8)))
+  )
+
+  ;; Reading
+
+  (func (export "read") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (f64.add
+      (f64.convert_i64_u (local.get 0))
+      (f64.add
+        (f64.promote_f32 (local.get 1))
+        (f64.add
+          (local.get 2)
+          (f64.add
+            (f64.convert_i32_u (local.get 3))
+            (f64.add
+              (f64.convert_i32_s (local.get 4))
+              (f64.add
+                (f64.promote_f32 (local.get 5))
+                (f64.add
+                  (f64.convert_i64_u (local.get 6))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 7))
+                    (local.get 8)
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32) (result i32)
+    (block (result i32) (local.get 0))
+  )
+  (func (export "as-loop-value") (param i32) (result i32)
+    (loop (result i32) (local.get 0))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.get 0)))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block $$l0 (result i32) (br_if $$l0 (local.get 0) (i32.const 1)))
+  )
+
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0 (local.get 0) (local.get 0))
+    )
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (br_table 0 1 2 (local.get 0))
+          (return (i32.const 0))
+        )
+        (return (i32.const 1))
+      )
+      (return (i32.const 2))
+    )
+    (i32.const 3)
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.get 0))
+  )
+
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 0)) (else (i32.const 0)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (i32.const 1)) (else (local.get 0)))
+  )
+)`);
+
+// ./test/core/local_get.wast:109
+assert_return(() => invoke($0, `type-local-i32`, []), [value("i32", 0)]);
+
+// ./test/core/local_get.wast:110
+assert_return(() => invoke($0, `type-local-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/local_get.wast:111
+assert_return(() => invoke($0, `type-local-f32`, []), [value("f32", 0)]);
+
+// ./test/core/local_get.wast:112
+assert_return(() => invoke($0, `type-local-f64`, []), [value("f64", 0)]);
+
+// ./test/core/local_get.wast:114
+assert_return(() => invoke($0, `type-param-i32`, [2]), [value("i32", 2)]);
+
+// ./test/core/local_get.wast:115
+assert_return(() => invoke($0, `type-param-i64`, [3n]), [value("i64", 3n)]);
+
+// ./test/core/local_get.wast:116
+assert_return(() => invoke($0, `type-param-f32`, [value("f32", 4.4)]), [value("f32", 4.4)]);
+
+// ./test/core/local_get.wast:117
+assert_return(() => invoke($0, `type-param-f64`, [value("f64", 5.5)]), [value("f64", 5.5)]);
+
+// ./test/core/local_get.wast:119
+assert_return(() => invoke($0, `as-block-value`, [6]), [value("i32", 6)]);
+
+// ./test/core/local_get.wast:120
+assert_return(() => invoke($0, `as-loop-value`, [7]), [value("i32", 7)]);
+
+// ./test/core/local_get.wast:122
+assert_return(() => invoke($0, `as-br-value`, [8]), [value("i32", 8)]);
+
+// ./test/core/local_get.wast:123
+assert_return(() => invoke($0, `as-br_if-value`, [9]), [value("i32", 9)]);
+
+// ./test/core/local_get.wast:124
+assert_return(() => invoke($0, `as-br_if-value-cond`, [10]), [value("i32", 10)]);
+
+// ./test/core/local_get.wast:125
+assert_return(() => invoke($0, `as-br_table-value`, [1]), [value("i32", 2)]);
+
+// ./test/core/local_get.wast:127
+assert_return(() => invoke($0, `as-return-value`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_get.wast:129
+assert_return(() => invoke($0, `as-if-then`, [1]), [value("i32", 1)]);
+
+// ./test/core/local_get.wast:130
+assert_return(() => invoke($0, `as-if-else`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_get.wast:132
+assert_return(() => invoke($0, `type-mixed`, [1n, value("f32", 2.2), value("f64", 3.3), 4, 5]), []);
+
+// ./test/core/local_get.wast:138
+assert_return(
+  () => invoke($0, `read`, [1n, value("f32", 2), value("f64", 3.3), 4, 5]),
+  [value("f64", 34.8)],
+);
+
+// ./test/core/local_get.wast:148
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i64) (local i32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:152
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i32) (local f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:156
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result f64) (local f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:164
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param i32) (result i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:168
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f32) (result i32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:172
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f64 i64) (result f64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:180
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-i32 (local i32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:184
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-i64 (local i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:188
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-f32 (local f32) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:192
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-f64 (local f64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_get.wast:200
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-local (local i32 i64) (local.get 3) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:204
+assert_invalid(
+  () => instantiate(`(module (func $$large-local (local i32 i64) (local.get 14324343) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:209
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-param (param i32 i64) (local.get 2) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:213
+assert_invalid(
+  () => instantiate(`(module (func $$large-param (param i32 i64) (local.get 714324343) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:218
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-mixed (param i32) (local i32 i64) (local.get 3) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_get.wast:222
+assert_invalid(
+  () => instantiate(`(module (func $$large-mixed (param i64) (local i32 i64) (local.get 214324343) drop))`),
+  `unknown local`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/local_set.wast.js b/js/src/jit-test/tests/wasm/spec/spec/local_set.wast.js
new file mode 100644
index 0000000000..f022fa00bf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/local_set.wast.js
@@ -0,0 +1,442 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/local_set.wast
+
+// ./test/core/local_set.wast:3
+let $0 = instantiate(`(module
+  ;; Typing
+
+  (func (export "type-local-i32") (local i32) (local.set 0 (i32.const 0)))
+  (func (export "type-local-i64") (local i64) (local.set 0 (i64.const 0)))
+  (func (export "type-local-f32") (local f32) (local.set 0 (f32.const 0)))
+  (func (export "type-local-f64") (local f64) (local.set 0 (f64.const 0)))
+
+  (func (export "type-param-i32") (param i32) (local.set 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (local.set 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (local.set 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (local.set 0 (f64.const 12.2)))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
+    (local.set 0 (i64.const 0))
+    (local.set 1 (f32.const 0))
+    (local.set 2 (f64.const 0))
+    (local.set 3 (i32.const 0))
+    (local.set 4 (i32.const 0))
+    (local.set 5 (f32.const 0))
+    (local.set 6 (i64.const 0))
+    (local.set 7 (i64.const 0))
+    (local.set 8 (f64.const 0))
+  )
+
+  ;; Writing
+
+  (func (export "write") (param i64 f32 f64 i32 i32) (result i64)
+    (local f32 i64 i64 f64)
+    (local.set 1 (f32.const -0.3))
+    (local.set 3 (i32.const 40))
+    (local.set 4 (i32.const -7))
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (i64.trunc_f64_s
+      (f64.add
+        (f64.convert_i64_u (local.get 0))
+        (f64.add
+          (f64.promote_f32 (local.get 1))
+          (f64.add
+            (local.get 2)
+            (f64.add
+              (f64.convert_i32_u (local.get 3))
+              (f64.add
+                (f64.convert_i32_s (local.get 4))
+                (f64.add
+                  (f64.promote_f32 (local.get 5))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 6))
+                    (f64.add
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32)
+    (block (local.set 0 (i32.const 1)))
+  )
+  (func (export "as-loop-value") (param i32)
+    (loop (local.set 0 (i32.const 3)))
+  )
+
+  (func (export "as-br-value") (param i32)
+    (block (br 0 (local.set 0 (i32.const 9))))
+  )
+  (func (export "as-br_if-value") (param i32)
+    (block
+      (br_if 0 (local.set 0 (i32.const 8)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32)
+    (block
+      (br_if 0 (i32.const 6) (local.set 0 (i32.const 9)))
+    )
+  )
+  (func (export "as-br_table-value") (param i32)
+    (block
+      (br_table 0 (local.set 0 (i32.const 10)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value") (param i32)
+    (return (local.set 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-then") (param i32)
+    (if (local.get 0) (then (local.set 0 (i32.const 3))))
+  )
+  (func (export "as-if-else") (param i32)
+    (if (local.get 0) (then) (else (local.set 0 (i32.const 1))))
+  )
+)`);
+
+// ./test/core/local_set.wast:107
+assert_return(() => invoke($0, `type-local-i32`, []), []);
+
+// ./test/core/local_set.wast:108
+assert_return(() => invoke($0, `type-local-i64`, []), []);
+
+// ./test/core/local_set.wast:109
+assert_return(() => invoke($0, `type-local-f32`, []), []);
+
+// ./test/core/local_set.wast:110
+assert_return(() => invoke($0, `type-local-f64`, []), []);
+
+// ./test/core/local_set.wast:112
+assert_return(() => invoke($0, `type-param-i32`, [2]), []);
+
+// ./test/core/local_set.wast:113
+assert_return(() => invoke($0, `type-param-i64`, [3n]), []);
+
+// ./test/core/local_set.wast:114
+assert_return(() => invoke($0, `type-param-f32`, [value("f32", 4.4)]), []);
+
+// ./test/core/local_set.wast:115
+assert_return(() => invoke($0, `type-param-f64`, [value("f64", 5.5)]), []);
+
+// ./test/core/local_set.wast:117
+assert_return(() => invoke($0, `as-block-value`, [0]), []);
+
+// ./test/core/local_set.wast:118
+assert_return(() => invoke($0, `as-loop-value`, [0]), []);
+
+// ./test/core/local_set.wast:120
+assert_return(() => invoke($0, `as-br-value`, [0]), []);
+
+// ./test/core/local_set.wast:121
+assert_return(() => invoke($0, `as-br_if-value`, [0]), []);
+
+// ./test/core/local_set.wast:122
+assert_return(() => invoke($0, `as-br_if-value-cond`, [0]), []);
+
+// ./test/core/local_set.wast:123
+assert_return(() => invoke($0, `as-br_table-value`, [0]), []);
+
+// ./test/core/local_set.wast:125
+assert_return(() => invoke($0, `as-return-value`, [0]), []);
+
+// ./test/core/local_set.wast:127
+assert_return(() => invoke($0, `as-if-then`, [1]), []);
+
+// ./test/core/local_set.wast:128
+assert_return(() => invoke($0, `as-if-else`, [0]), []);
+
+// ./test/core/local_set.wast:130
+assert_return(() => invoke($0, `type-mixed`, [1n, value("f32", 2.2), value("f64", 3.3), 4, 5]), []);
+
+// ./test/core/local_set.wast:136
+assert_return(
+  () => invoke($0, `write`, [1n, value("f32", 2), value("f64", 3.3), 4, 5]),
+  [value("i64", 56n)],
+);
+
+// ./test/core/local_set.wast:147
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-void-vs-num (local i32) (local.set 0 (nop))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:151
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-num-vs-num (local i32) (local.set 0 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:155
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-num-vs-num (local f32) (local.set 0 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:159
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-num-vs-num (local f64 i64) (local.set 1 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:168
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-void-vs-num (param i32) (local.set 0 (nop))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:172
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-num-vs-num (param i32) (local.set 0 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:176
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-num-vs-num (param f32) (local.set 0 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:180
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-num-vs-num (param f64 i64) (local.set 1 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:185
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num (param i32)
+      (local.set 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:193
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-block (param i32)
+      (i32.const 0)
+      (block (local.set 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:202
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-loop (param i32)
+      (i32.const 0)
+      (loop (local.set 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:211
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-then (param i32)
+      (i32.const 0)
+      (if (i32.const 1) (then (local.set 0)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:220
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-else (param i32)
+      (i32.const 0)
+      (if (result i32) (i32.const 0) (then (i32.const 0)) (else (local.set 0)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:229
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-br (param i32)
+      (i32.const 0)
+      (block (br 0 (local.set 0)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:238
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-br_if (param i32)
+      (i32.const 0)
+      (block (br_if 0 (local.set 0)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:247
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-br_table (param i32)
+      (i32.const 0)
+      (block (br_table 0 (local.set 0)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:256
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-return (param i32)
+      (return (local.set 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:264
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-select (param i32)
+      (select (local.set 0) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:272
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-call (param i32)
+      (call 1 (local.set 0))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:281
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-param-arg-empty-vs-num-in-call_indirect (param i32)
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (local.set 0) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:300
+assert_invalid(
+  () => instantiate(`(module (func $$type-mixed-arg-num-vs-num (param f32) (local i32) (local.set 1 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:304
+assert_invalid(
+  () => instantiate(`(module (func $$type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.set 1 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:308
+assert_invalid(
+  () => instantiate(`(module (func $$type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.set 1 (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:316
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-i32 (param i32) (result i32) (local.set 0 (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:320
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-i64 (param i64) (result i64) (local.set 0 (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:324
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-f32 (param f32) (result f32) (local.set 0 (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:328
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-vs-f64 (param f64) (result f64) (local.set 0 (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_set.wast:336
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-local (local i32 i64) (local.set 3 (i32.const 0))))`),
+  `unknown local`,
+);
+
+// ./test/core/local_set.wast:340
+assert_invalid(
+  () => instantiate(`(module (func $$large-local (local i32 i64) (local.set 14324343 (i32.const 0))))`),
+  `unknown local`,
+);
+
+// ./test/core/local_set.wast:345
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-param (param i32 i64) (local.set 2 (i32.const 0))))`),
+  `unknown local`,
+);
+
+// ./test/core/local_set.wast:349
+assert_invalid(
+  () => instantiate(`(module (func $$large-param (param i32 i64) (local.set 714324343 (i32.const 0))))`),
+  `unknown local`,
+);
+
+// ./test/core/local_set.wast:354
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-mixed (param i32) (local i32 i64) (local.set 3 (i32.const 0))))`),
+  `unknown local`,
+);
+
+// ./test/core/local_set.wast:358
+assert_invalid(
+  () => instantiate(`(module (func $$large-mixed (param i64) (local i32 i64) (local.set 214324343 (i32.const 0))))`),
+  `unknown local`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/local_tee.wast.js b/js/src/jit-test/tests/wasm/spec/spec/local_tee.wast.js
new file mode 100644
index 0000000000..c02e2044e7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/local_tee.wast.js
@@ -0,0 +1,806 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/local_tee.wast
+
+// ./test/core/local_tee.wast:3
+let $0 = instantiate(`(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.tee 0 (i32.const 0)))
+  (func (export "type-local-i64") (result i64) (local i64) (local.tee 0 (i64.const 0)))
+  (func (export "type-local-f32") (result f32) (local f32) (local.tee 0 (f32.const 0)))
+  (func (export "type-local-f64") (result f64) (local f64) (local.tee 0 (f64.const 0)))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.tee 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (result i64) (local.tee 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (result f32) (local.tee 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (result f64) (local.tee 0 (f64.const 12.2)))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.tee 0 (i64.const 0))))
+    (drop (f32.neg (local.tee 1 (f32.const 0))))
+    (drop (f64.neg (local.tee 2 (f64.const 0))))
+    (drop (i32.eqz (local.tee 3 (i32.const 0))))
+    (drop (i32.eqz (local.tee 4 (i32.const 0))))
+    (drop (f32.neg (local.tee 5 (f32.const 0))))
+    (drop (i64.eqz (local.tee 6 (i64.const 0))))
+    (drop (i64.eqz (local.tee 7 (i64.const 0))))
+    (drop (f64.neg (local.tee 8 (f64.const 0))))
+  )
+
+  ;; Writing
+
+  (func (export "write") (param i64 f32 f64 i32 i32) (result i64) (local f32 i64 i64 f64)
+    (drop (local.tee 1 (f32.const -0.3)))
+    (drop (local.tee 3 (i32.const 40)))
+    (drop (local.tee 4 (i32.const -7)))
+    (drop (local.tee 5 (f32.const 5.5)))
+    (drop (local.tee 6 (i64.const 6)))
+    (drop (local.tee 8 (f64.const 8)))
+    (i64.trunc_f64_s
+      (f64.add
+        (f64.convert_i64_u (local.get 0))
+        (f64.add
+          (f64.promote_f32 (local.get 1))
+          (f64.add
+            (local.get 2)
+            (f64.add
+              (f64.convert_i32_u (local.get 3))
+              (f64.add
+                (f64.convert_i32_s (local.get 4))
+                (f64.add
+                  (f64.promote_f32 (local.get 5))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 6))
+                    (f64.add
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; Result
+
+  (func (export "result") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (f64.add
+      (f64.convert_i64_u (local.tee 0 (i64.const 1)))
+      (f64.add
+        (f64.promote_f32 (local.tee 1 (f32.const 2)))
+        (f64.add
+          (local.tee 2 (f64.const 3.3))
+          (f64.add
+            (f64.convert_i32_u (local.tee 3 (i32.const 4)))
+            (f64.add
+              (f64.convert_i32_s (local.tee 4 (i32.const 5)))
+              (f64.add
+                (f64.promote_f32 (local.tee 5 (f32.const 5.5)))
+                (f64.add
+                  (f64.convert_i64_u (local.tee 6 (i64.const 6)))
+                  (f64.add
+                    (f64.convert_i64_u (local.tee 7 (i64.const 0)))
+                    (local.tee 8 (f64.const 8))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  (func $$dummy)
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (result i32) (local.tee 0 (i32.const 1)) (call $$dummy))
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (result i32) (call $$dummy) (local.tee 0 (i32.const 1)) (call $$dummy))
+  )
+  (func (export "as-block-last") (param i32) (result i32)
+    (block (result i32) (call $$dummy) (call $$dummy) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (local.tee 0 (i32.const 3)) (call $$dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $$dummy) (local.tee 0 (i32.const 4)) (call $$dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $$dummy) (call $$dummy) (local.tee 0 (i32.const 5)))
+  )
+
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.tee 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond") (param i32)
+    (block (br_if 0 (local.tee 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (local.tee 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (local.tee 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index") (param i32)
+    (block (br_table 0 0 0 (local.tee 0 (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (local.tee 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (local.tee 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.tee 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (if (result i32) (local.tee 0 (i32.const 2))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (local.tee 0 (i32.const 3))) (else (local.get 0))
+    )
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (local.get 0)) (else (local.tee 0 (i32.const 4)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (local.tee 0 (i32.const 5)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (local.tee 0 (i32.const 6)) (local.get 1))
+  )
+  (func (export "as-select-cond") (param i32) (result i32)
+    (select (i32.const 0) (i32.const 1) (local.tee 0 (i32.const 7)))
+  )
+
+  (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (param i32) (result i32)
+    (call $$f (local.tee 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (param i32) (result i32)
+    (call $$f (i32.const 1) (local.tee 0 (i32.const 13)) (i32.const 3))
+  )
+  (func (export "as-call-last") (param i32) (result i32)
+    (call $$f (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 14)))
+  )
+
+  (type $$sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$f))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (call_indirect (type $$sig)
+      (local.tee 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (local.tee 0 (i32.const 2)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 3)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (param i32) (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (local.tee 0 (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (local.tee 0 (i32.const 1)))
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (local.tee 0 (i32.const 1)))
+  )
+  (global $$g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $$g (local.tee 0 (i32.const 1)))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (param i32) (result i32)
+    (i32.load (local.tee 0 (i32.const 1)))
+  )
+  (func (export "as-loadN-address") (param i32) (result i32)
+    (i32.load8_s (local.tee 0 (i32.const 3)))
+  )
+
+  (func (export "as-store-address") (param i32)
+    (i32.store (local.tee 0 (i32.const 30)) (i32.const 7))
+  )
+  (func (export "as-store-value") (param i32)
+    (i32.store (i32.const 2) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-storeN-address") (param i32)
+    (i32.store8 (local.tee 0 (i32.const 1)) (i32.const 7))
+  )
+  (func (export "as-storeN-value") (param i32)
+    (i32.store16 (i32.const 2) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (param f32) (result f32)
+    (f32.neg (local.tee 0 (f32.const nan:0x0f1e2)))
+  )
+
+  (func (export "as-binary-left") (param i32) (result i32)
+    (i32.add (local.tee 0 (i32.const 3)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (param i32) (result i32)
+    (i32.sub (i32.const 10) (local.tee 0 (i32.const 4)))
+  )
+
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz (local.tee 0 (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (i32.le_s (local.tee 0 (i32.const 43)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (i32.ne (i32.const 10) (local.tee 0 (i32.const 42)))
+  )
+
+  (func (export "as-convert-operand") (param i64) (result i32)
+    (i32.wrap_i64 (local.tee 0 (i64.const 41)))
+  )
+
+  (func (export "as-memory.grow-size") (param i32) (result i32)
+    (memory.grow (local.tee 0 (i32.const 40)))
+  )
+
+)`);
+
+// ./test/core/local_tee.wast:280
+assert_return(() => invoke($0, `type-local-i32`, []), [value("i32", 0)]);
+
+// ./test/core/local_tee.wast:281
+assert_return(() => invoke($0, `type-local-i64`, []), [value("i64", 0n)]);
+
+// ./test/core/local_tee.wast:282
+assert_return(() => invoke($0, `type-local-f32`, []), [value("f32", 0)]);
+
+// ./test/core/local_tee.wast:283
+assert_return(() => invoke($0, `type-local-f64`, []), [value("f64", 0)]);
+
+// ./test/core/local_tee.wast:285
+assert_return(() => invoke($0, `type-param-i32`, [2]), [value("i32", 10)]);
+
+// ./test/core/local_tee.wast:286
+assert_return(() => invoke($0, `type-param-i64`, [3n]), [value("i64", 11n)]);
+
+// ./test/core/local_tee.wast:287
+assert_return(() => invoke($0, `type-param-f32`, [value("f32", 4.4)]), [value("f32", 11.1)]);
+
+// ./test/core/local_tee.wast:288
+assert_return(() => invoke($0, `type-param-f64`, [value("f64", 5.5)]), [value("f64", 12.2)]);
+
+// ./test/core/local_tee.wast:290
+assert_return(() => invoke($0, `as-block-first`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:291
+assert_return(() => invoke($0, `as-block-mid`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:292
+assert_return(() => invoke($0, `as-block-last`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:294
+assert_return(() => invoke($0, `as-loop-first`, [0]), [value("i32", 3)]);
+
+// ./test/core/local_tee.wast:295
+assert_return(() => invoke($0, `as-loop-mid`, [0]), [value("i32", 4)]);
+
+// ./test/core/local_tee.wast:296
+assert_return(() => invoke($0, `as-loop-last`, [0]), [value("i32", 5)]);
+
+// ./test/core/local_tee.wast:298
+assert_return(() => invoke($0, `as-br-value`, [0]), [value("i32", 9)]);
+
+// ./test/core/local_tee.wast:300
+assert_return(() => invoke($0, `as-br_if-cond`, [0]), []);
+
+// ./test/core/local_tee.wast:301
+assert_return(() => invoke($0, `as-br_if-value`, [0]), [value("i32", 8)]);
+
+// ./test/core/local_tee.wast:302
+assert_return(() => invoke($0, `as-br_if-value-cond`, [0]), [value("i32", 6)]);
+
+// ./test/core/local_tee.wast:304
+assert_return(() => invoke($0, `as-br_table-index`, [0]), []);
+
+// ./test/core/local_tee.wast:305
+assert_return(() => invoke($0, `as-br_table-value`, [0]), [value("i32", 10)]);
+
+// ./test/core/local_tee.wast:306
+assert_return(() => invoke($0, `as-br_table-value-index`, [0]), [value("i32", 6)]);
+
+// ./test/core/local_tee.wast:308
+assert_return(() => invoke($0, `as-return-value`, [0]), [value("i32", 7)]);
+
+// ./test/core/local_tee.wast:310
+assert_return(() => invoke($0, `as-if-cond`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_tee.wast:311
+assert_return(() => invoke($0, `as-if-then`, [1]), [value("i32", 3)]);
+
+// ./test/core/local_tee.wast:312
+assert_return(() => invoke($0, `as-if-else`, [0]), [value("i32", 4)]);
+
+// ./test/core/local_tee.wast:314
+assert_return(() => invoke($0, `as-select-first`, [0, 1]), [value("i32", 5)]);
+
+// ./test/core/local_tee.wast:315
+assert_return(() => invoke($0, `as-select-second`, [0, 0]), [value("i32", 6)]);
+
+// ./test/core/local_tee.wast:316
+assert_return(() => invoke($0, `as-select-cond`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_tee.wast:318
+assert_return(() => invoke($0, `as-call-first`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:319
+assert_return(() => invoke($0, `as-call-mid`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:320
+assert_return(() => invoke($0, `as-call-last`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:322
+assert_return(() => invoke($0, `as-call_indirect-first`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:323
+assert_return(() => invoke($0, `as-call_indirect-mid`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:324
+assert_return(() => invoke($0, `as-call_indirect-last`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:325
+assert_return(() => invoke($0, `as-call_indirect-index`, [0]), [value("i32", -1)]);
+
+// ./test/core/local_tee.wast:327
+assert_return(() => invoke($0, `as-local.set-value`, []), []);
+
+// ./test/core/local_tee.wast:328
+assert_return(() => invoke($0, `as-local.tee-value`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:329
+assert_return(() => invoke($0, `as-global.set-value`, []), []);
+
+// ./test/core/local_tee.wast:331
+assert_return(() => invoke($0, `as-load-address`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_tee.wast:332
+assert_return(() => invoke($0, `as-loadN-address`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_tee.wast:333
+assert_return(() => invoke($0, `as-store-address`, [0]), []);
+
+// ./test/core/local_tee.wast:334
+assert_return(() => invoke($0, `as-store-value`, [0]), []);
+
+// ./test/core/local_tee.wast:335
+assert_return(() => invoke($0, `as-storeN-address`, [0]), []);
+
+// ./test/core/local_tee.wast:336
+assert_return(() => invoke($0, `as-storeN-value`, [0]), []);
+
+// ./test/core/local_tee.wast:338
+assert_return(
+  () => invoke($0, `as-unary-operand`, [value("f32", 0)]),
+  [bytes("f32", [0xe2, 0xf1, 0x80, 0xff])],
+);
+
+// ./test/core/local_tee.wast:339
+assert_return(() => invoke($0, `as-binary-left`, [0]), [value("i32", 13)]);
+
+// ./test/core/local_tee.wast:340
+assert_return(() => invoke($0, `as-binary-right`, [0]), [value("i32", 6)]);
+
+// ./test/core/local_tee.wast:341
+assert_return(() => invoke($0, `as-test-operand`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:342
+assert_return(() => invoke($0, `as-compare-left`, [0]), [value("i32", 0)]);
+
+// ./test/core/local_tee.wast:343
+assert_return(() => invoke($0, `as-compare-right`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:344
+assert_return(() => invoke($0, `as-convert-operand`, [0n]), [value("i32", 41)]);
+
+// ./test/core/local_tee.wast:345
+assert_return(() => invoke($0, `as-memory.grow-size`, [0]), [value("i32", 1)]);
+
+// ./test/core/local_tee.wast:347
+assert_return(() => invoke($0, `type-mixed`, [1n, value("f32", 2.2), value("f64", 3.3), 4, 5]), []);
+
+// ./test/core/local_tee.wast:353
+assert_return(
+  () => invoke($0, `write`, [1n, value("f32", 2), value("f64", 3.3), 4, 5]),
+  [value("i64", 56n)],
+);
+
+// ./test/core/local_tee.wast:360
+assert_return(
+  () => invoke($0, `result`, [-1n, value("f32", -2), value("f64", -3.3), -4, -5]),
+  [value("f64", 34.8)],
+);
+
+// ./test/core/local_tee.wast:370
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (result i64) (local i32) (local.tee 0 (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:374
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (local f32) (i32.eqz (local.tee 0 (f32.const 0)))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:378
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-num-vs-num (local f64 i64) (f64.neg (local.tee 1 (i64.const 0)))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:383
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-void-vs-num (local i32) (local.tee 0 (nop))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:387
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-num-vs-num (local i32) (local.tee 0 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:391
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-num-vs-num (local f32) (local.tee 0 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:395
+assert_invalid(
+  () => instantiate(`(module (func $$type-local-arg-num-vs-num (local f64 i64) (local.tee 1 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:403
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param i32) (result i64) (local.get 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:407
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:411
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:416
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-void-vs-num (param i32) (local.tee 0 (nop))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:420
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-num-vs-num (param i32) (local.tee 0 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:424
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-num-vs-num (param f32) (local.tee 0 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:428
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-arg-num-vs-num (param f64 i64) (local.tee 1 (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:433
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num (param i32)
+      (local.tee 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:441
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-block (param i32)
+      (i32.const 0)
+      (block (local.tee 0) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:450
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-loop (param i32)
+      (i32.const 0)
+      (loop (local.tee 0) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:459
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-then (param i32)
+      (i32.const 0) (i32.const 0)
+      (if (then (local.tee 0) (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:468
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-else (param i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (local.tee 0))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:477
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-br (param i32)
+      (i32.const 0)
+      (block (br 0 (local.tee 0)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:486
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-br_if (param i32)
+      (i32.const 0)
+      (block (br_if 0 (local.tee 0) (i32.const 1)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:495
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-br_table (param i32)
+      (i32.const 0)
+      (block (br_table 0 (local.tee 0)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:504
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-return (param i32)
+      (return (local.tee 0)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:512
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-select (param i32)
+      (select (local.tee 0) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:520
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-call (param i32)
+      (call 1 (local.tee 0)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:529
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-param-arg-empty-vs-num-in-call_indirect (param i32)
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (local.tee 0) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:545
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-local.set (param i32)
+      (local.set 0 (local.tee 0)) (local.get 0) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:553
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-param-arg-empty-vs-num-in-local.tee (param i32)
+      (local.tee 0 (local.tee 0)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:561
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-param-arg-empty-vs-num-in-global.set (param i32)
+      (global.set $$x (local.tee 0)) (global.get $$x) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:570
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-param-arg-empty-vs-num-in-memory.grow (param i32)
+      (memory.grow (local.tee 0)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:579
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-param-arg-empty-vs-num-in-load (param i32)
+      (i32.load (local.tee 0)) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:588
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-param-arg-empty-vs-num-in-store (param i32)
+      (i32.store (local.tee 0) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:598
+assert_invalid(
+  () => instantiate(`(module (func $$type-mixed-arg-num-vs-num (param f32) (local i32) (local.tee 1 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:602
+assert_invalid(
+  () => instantiate(`(module (func $$type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.tee 1 (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:606
+assert_invalid(
+  () => instantiate(`(module (func $$type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.tee 1 (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/local_tee.wast:614
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-local (local i32 i64) (local.tee 3 (i32.const 0)) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_tee.wast:618
+assert_invalid(
+  () => instantiate(`(module (func $$large-local (local i32 i64) (local.tee 14324343 (i32.const 0)) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_tee.wast:623
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-param (param i32 i64) (local.tee 2 (i32.const 0)) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_tee.wast:627
+assert_invalid(
+  () => instantiate(`(module (func $$large-param (param i32 i64) (local.tee 714324343 (i32.const 0)) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_tee.wast:632
+assert_invalid(
+  () => instantiate(`(module (func $$unbound-mixed (param i32) (local i32 i64) (local.tee 3 (i32.const 0)) drop))`),
+  `unknown local`,
+);
+
+// ./test/core/local_tee.wast:636
+assert_invalid(
+  () => instantiate(`(module (func $$large-mixed (param i64) (local i32 i64) (local.tee 214324343 (i32.const 0)) drop))`),
+  `unknown local`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/loop.wast.js b/js/src/jit-test/tests/wasm/spec/spec/loop.wast.js
new file mode 100644
index 0000000000..d00d9d4a6e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/loop.wast.js
@@ -0,0 +1,986 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/loop.wast
+
+// ./test/core/loop.wast:3
+let $0 = instantiate(`(module
+  (memory 1)
+
+  (func $$dummy)
+
+  (func (export "empty")
+    (loop)
+    (loop $$l)
+  )
+
+  (func (export "singular") (result i32)
+    (loop (nop))
+    (loop (result i32) (i32.const 7))
+  )
+
+  (func (export "multi") (result i32)
+    (loop (call $$dummy) (call $$dummy) (call $$dummy) (call $$dummy))
+    (loop (result i32) (call $$dummy) (call $$dummy) (i32.const 8) (call $$dummy))
+    (drop)
+    (loop (result i32 i64 i32)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i32.const 8) (call $$dummy)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i64.const 7) (call $$dummy)
+      (call $$dummy) (call $$dummy) (call $$dummy) (i32.const 9) (call $$dummy)
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (result i32)
+    (loop (result i32)
+      (loop (call $$dummy) (block) (nop))
+      (loop (result i32) (call $$dummy) (i32.const 9))
+    )
+  )
+
+  (func (export "deep") (result i32)
+    (loop (result i32) (block (result i32)
+      (loop (result i32) (block (result i32)
+        (loop (result i32) (block (result i32)
+          (loop (result i32) (block (result i32)
+            (loop (result i32) (block (result i32)
+              (loop (result i32) (block (result i32)
+                (loop (result i32) (block (result i32)
+                  (loop (result i32) (block (result i32)
+                    (loop (result i32) (block (result i32)
+                      (loop (result i32) (block (result i32)
+                        (loop (result i32) (block (result i32)
+                          (loop (result i32) (block (result i32)
+                            (loop (result i32) (block (result i32)
+                              (loop (result i32) (block (result i32)
+                                (loop (result i32) (block (result i32)
+                                  (loop (result i32) (block (result i32)
+                                    (loop (result i32) (block (result i32)
+                                      (loop (result i32) (block (result i32)
+                                        (loop (result i32) (block (result i32)
+                                          (loop (result i32) (block (result i32)
+                                            (call $$dummy) (i32.const 150)
+                                          ))
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+
+  (func (export "as-select-first") (result i32)
+    (select (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (loop (result i32) (i32.const 1)) (if (then (call $$dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (loop (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $$check)
+        (i32.const 1) (i32.const 2) (loop (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (loop (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (loop (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (loop (result i32) (i32.const 1)))
+  )
+
+  (func $$f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $$f (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (loop (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (loop (result i32) (i32.const 1)))
+  )
+  (global $$a (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$a (loop (result i32) (i32.const 1)))
+    (global.get $$a)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (loop (result i32) (call $$dummy) (i32.const 13)))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (loop (result i32) (call $$dummy) (i32.const 3))
+      (loop (result i32) (call $$dummy) (i32.const 4))
+    )
+  )
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (loop (result i32) (call $$dummy) (i32.const 13)))
+  )
+  (func (export "as-compare-operand") (result i32)
+    (f32.gt
+      (loop (result f32) (call $$dummy) (f32.const 3))
+      (loop (result f32) (call $$dummy) (f32.const 3))
+    )
+  )
+  (func (export "as-binary-operands") (result i32)
+    (i32.mul
+      (loop (result i32 i32)
+        (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4)
+      )
+    )
+  )
+  (func (export "as-compare-operands") (result i32)
+    (f32.gt
+      (loop (result f32 f32)
+        (call $$dummy) (f32.const 3) (call $$dummy) (f32.const 3)
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (result i32)
+    (loop (result i32 i32)
+      (call $$dummy) (i32.const 3) (call $$dummy) (i32.const 4)
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (block (loop (br 1) (br 0) (unreachable)))
+    (block (loop (br_if 1 (i32.const 1)) (unreachable)))
+    (block (loop (br_table 1 (i32.const 0)) (unreachable)))
+    (block (loop (br_table 1 1 1 (i32.const 1)) (unreachable)))
+    (i32.const 19)
+  )
+  (func (export "break-value") (result i32)
+    (block (result i32)
+      (i32.const 0)
+      (loop (param i32)
+        (block (br 2 (i32.const 18)))
+        (br 0 (i32.const 20))
+      )
+      (i32.const 19)
+    )
+  )
+  (func (export "break-multi-value") (result i32 i32 i64)
+    (block (result i32 i32 i64)
+      (i32.const 0) (i32.const 0) (i64.const 0)
+      (loop (param i32 i32 i64)
+        (block (br 2 (i32.const 18) (i32.const -18) (i64.const 18)))
+        (br 0 (i32.const 20) (i32.const -20) (i64.const 20))
+      )
+      (i32.const 19) (i32.const -19) (i64.const 19)
+    )
+  )
+  (func (export "break-repeated") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (br 1 (i32.const 18))
+        (br 1 (i32.const 19))
+        (drop (br_if 1 (i32.const 20) (i32.const 0)))
+        (drop (br_if 1 (i32.const 20) (i32.const 1)))
+        (br 1 (i32.const 21))
+        (br_table 1 (i32.const 22) (i32.const 0))
+        (br_table 1 1 1 (i32.const 23) (i32.const 1))
+        (i32.const 21)
+      )
+    )
+  )
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
+    (local.get 0)
+  )
+  (func (export "cont-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
+    (local.get 0)
+  )
+
+  (func (export "param") (result i32)
+    (i32.const 1)
+    (loop (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+    )
+  )
+  (func (export "params") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32)
+      (i32.add)
+    )
+  )
+  (func (export "params-id") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32 i32))
+    (i32.add)
+  )
+  (func (export "param-break") (result i32)
+    (local $$x i32)
+    (i32.const 1)
+    (loop (param i32) (result i32)
+      (i32.const 4)
+      (i32.add)
+      (local.tee $$x)
+      (local.get $$x)
+      (i32.const 10)
+      (i32.lt_u)
+      (br_if 0)
+    )
+  )
+  (func (export "params-break") (result i32)
+    (local $$x i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32)
+      (i32.add)
+      (local.tee $$x)
+      (i32.const 3)
+      (local.get $$x)
+      (i32.const 10)
+      (i32.lt_u)
+      (br_if 0)
+      (drop)
+    )
+  )
+  (func (export "params-id-break") (result i32)
+    (local $$x i32)
+    (local.set $$x (i32.const 0))
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32 i32)
+      (local.set $$x (i32.add (local.get $$x) (i32.const 1)))
+      (br_if 0 (i32.lt_u (local.get $$x) (i32.const 10)))
+    )
+    (i32.add)
+  )
+
+  (func $$fx (export "effects") (result i32)
+    (local i32)
+    (block
+      (loop
+        (local.set 0 (i32.const 1))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+        (br 1)
+        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+      )
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+
+  (func (export "while") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (loop
+        (br_if 1 (i64.eqz (local.get 0)))
+        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
+        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+
+  (func (export "for") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (i64.const 1))
+    (local.set 2 (i64.const 2))
+    (block
+      (loop
+        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
+        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
+        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+
+  (func (export "nesting") (param f32 f32) (result f32)
+    (local f32 f32)
+    (block
+      (loop
+        (br_if 1 (f32.eq (local.get 0) (f32.const 0)))
+        (local.set 2 (local.get 1))
+        (block
+          (loop
+            (br_if 1 (f32.eq (local.get 2) (f32.const 0)))
+            (br_if 3 (f32.lt (local.get 2) (f32.const 0)))
+            (local.set 3 (f32.add (local.get 3) (local.get 2)))
+            (local.set 2 (f32.sub (local.get 2) (f32.const 2)))
+            (br 0)
+          )
+        )
+        (local.set 3 (f32.div (local.get 3) (local.get 0)))
+        (local.set 0 (f32.sub (local.get 0) (f32.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 3)
+  )
+
+  (type $$block-sig-1 (func))
+  (type $$block-sig-2 (func (result i32)))
+  (type $$block-sig-3 (func (param $$x i32)))
+  (type $$block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (loop (type $$block-sig-1))
+    (loop (type $$block-sig-2) (i32.const 0))
+    (loop (type $$block-sig-3) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (loop (type $$block-sig-4))
+    (drop) (drop) (drop)
+    (loop (type $$block-sig-2) (result i32) (i32.const 0))
+    (loop (type $$block-sig-3) (param i32) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (loop (type $$block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+    )
+    (drop) (drop) (drop)
+  )
+)`);
+
+// ./test/core/loop.wast:430
+assert_return(() => invoke($0, `empty`, []), []);
+
+// ./test/core/loop.wast:431
+assert_return(() => invoke($0, `singular`, []), [value("i32", 7)]);
+
+// ./test/core/loop.wast:432
+assert_return(() => invoke($0, `multi`, []), [value("i32", 8)]);
+
+// ./test/core/loop.wast:433
+assert_return(() => invoke($0, `nested`, []), [value("i32", 9)]);
+
+// ./test/core/loop.wast:434
+assert_return(() => invoke($0, `deep`, []), [value("i32", 150)]);
+
+// ./test/core/loop.wast:436
+assert_return(() => invoke($0, `as-select-first`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:437
+assert_return(() => invoke($0, `as-select-mid`, []), [value("i32", 2)]);
+
+// ./test/core/loop.wast:438
+assert_return(() => invoke($0, `as-select-last`, []), [value("i32", 2)]);
+
+// ./test/core/loop.wast:440
+assert_return(() => invoke($0, `as-if-condition`, []), []);
+
+// ./test/core/loop.wast:441
+assert_return(() => invoke($0, `as-if-then`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:442
+assert_return(() => invoke($0, `as-if-else`, []), [value("i32", 2)]);
+
+// ./test/core/loop.wast:444
+assert_return(() => invoke($0, `as-br_if-first`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:445
+assert_return(() => invoke($0, `as-br_if-last`, []), [value("i32", 2)]);
+
+// ./test/core/loop.wast:447
+assert_return(() => invoke($0, `as-br_table-first`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:448
+assert_return(() => invoke($0, `as-br_table-last`, []), [value("i32", 2)]);
+
+// ./test/core/loop.wast:450
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:451
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 2)]);
+
+// ./test/core/loop.wast:452
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:454
+assert_return(() => invoke($0, `as-store-first`, []), []);
+
+// ./test/core/loop.wast:455
+assert_return(() => invoke($0, `as-store-last`, []), []);
+
+// ./test/core/loop.wast:457
+assert_return(() => invoke($0, `as-memory.grow-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:458
+assert_return(() => invoke($0, `as-call-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:459
+assert_return(() => invoke($0, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:460
+assert_return(() => invoke($0, `as-drop-operand`, []), []);
+
+// ./test/core/loop.wast:461
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:462
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:463
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:464
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:465
+assert_return(() => invoke($0, `as-load-operand`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:467
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("i32", 0)]);
+
+// ./test/core/loop.wast:468
+assert_return(() => invoke($0, `as-binary-operand`, []), [value("i32", 12)]);
+
+// ./test/core/loop.wast:469
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/loop.wast:470
+assert_return(() => invoke($0, `as-compare-operand`, []), [value("i32", 0)]);
+
+// ./test/core/loop.wast:471
+assert_return(() => invoke($0, `as-binary-operands`, []), [value("i32", 12)]);
+
+// ./test/core/loop.wast:472
+assert_return(() => invoke($0, `as-compare-operands`, []), [value("i32", 0)]);
+
+// ./test/core/loop.wast:473
+assert_return(() => invoke($0, `as-mixed-operands`, []), [value("i32", 27)]);
+
+// ./test/core/loop.wast:475
+assert_return(() => invoke($0, `break-bare`, []), [value("i32", 19)]);
+
+// ./test/core/loop.wast:476
+assert_return(() => invoke($0, `break-value`, []), [value("i32", 18)]);
+
+// ./test/core/loop.wast:477
+assert_return(
+  () => invoke($0, `break-multi-value`, []),
+  [value("i32", 18), value("i32", -18), value("i64", 18n)],
+);
+
+// ./test/core/loop.wast:480
+assert_return(() => invoke($0, `break-repeated`, []), [value("i32", 18)]);
+
+// ./test/core/loop.wast:481
+assert_return(() => invoke($0, `break-inner`, []), [value("i32", 31)]);
+
+// ./test/core/loop.wast:483
+assert_return(() => invoke($0, `param`, []), [value("i32", 3)]);
+
+// ./test/core/loop.wast:484
+assert_return(() => invoke($0, `params`, []), [value("i32", 3)]);
+
+// ./test/core/loop.wast:485
+assert_return(() => invoke($0, `params-id`, []), [value("i32", 3)]);
+
+// ./test/core/loop.wast:486
+assert_return(() => invoke($0, `param-break`, []), [value("i32", 13)]);
+
+// ./test/core/loop.wast:487
+assert_return(() => invoke($0, `params-break`, []), [value("i32", 12)]);
+
+// ./test/core/loop.wast:488
+assert_return(() => invoke($0, `params-id-break`, []), [value("i32", 3)]);
+
+// ./test/core/loop.wast:490
+assert_return(() => invoke($0, `effects`, []), [value("i32", 1)]);
+
+// ./test/core/loop.wast:492
+assert_return(() => invoke($0, `while`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/loop.wast:493
+assert_return(() => invoke($0, `while`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/loop.wast:494
+assert_return(() => invoke($0, `while`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/loop.wast:495
+assert_return(() => invoke($0, `while`, [3n]), [value("i64", 6n)]);
+
+// ./test/core/loop.wast:496
+assert_return(() => invoke($0, `while`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/loop.wast:497
+assert_return(() => invoke($0, `while`, [20n]), [value("i64", 2432902008176640000n)]);
+
+// ./test/core/loop.wast:499
+assert_return(() => invoke($0, `for`, [0n]), [value("i64", 1n)]);
+
+// ./test/core/loop.wast:500
+assert_return(() => invoke($0, `for`, [1n]), [value("i64", 1n)]);
+
+// ./test/core/loop.wast:501
+assert_return(() => invoke($0, `for`, [2n]), [value("i64", 2n)]);
+
+// ./test/core/loop.wast:502
+assert_return(() => invoke($0, `for`, [3n]), [value("i64", 6n)]);
+
+// ./test/core/loop.wast:503
+assert_return(() => invoke($0, `for`, [5n]), [value("i64", 120n)]);
+
+// ./test/core/loop.wast:504
+assert_return(() => invoke($0, `for`, [20n]), [value("i64", 2432902008176640000n)]);
+
+// ./test/core/loop.wast:506
+assert_return(() => invoke($0, `nesting`, [value("f32", 0), value("f32", 7)]), [value("f32", 0)]);
+
+// ./test/core/loop.wast:507
+assert_return(() => invoke($0, `nesting`, [value("f32", 7), value("f32", 0)]), [value("f32", 0)]);
+
+// ./test/core/loop.wast:508
+assert_return(() => invoke($0, `nesting`, [value("f32", 1), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/loop.wast:509
+assert_return(() => invoke($0, `nesting`, [value("f32", 1), value("f32", 2)]), [value("f32", 2)]);
+
+// ./test/core/loop.wast:510
+assert_return(() => invoke($0, `nesting`, [value("f32", 1), value("f32", 3)]), [value("f32", 4)]);
+
+// ./test/core/loop.wast:511
+assert_return(() => invoke($0, `nesting`, [value("f32", 1), value("f32", 4)]), [value("f32", 6)]);
+
+// ./test/core/loop.wast:512
+assert_return(() => invoke($0, `nesting`, [value("f32", 1), value("f32", 100)]), [value("f32", 2550)]);
+
+// ./test/core/loop.wast:513
+assert_return(() => invoke($0, `nesting`, [value("f32", 1), value("f32", 101)]), [value("f32", 2601)]);
+
+// ./test/core/loop.wast:514
+assert_return(() => invoke($0, `nesting`, [value("f32", 2), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/loop.wast:515
+assert_return(() => invoke($0, `nesting`, [value("f32", 3), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/loop.wast:516
+assert_return(() => invoke($0, `nesting`, [value("f32", 10), value("f32", 1)]), [value("f32", 1)]);
+
+// ./test/core/loop.wast:517
+assert_return(() => invoke($0, `nesting`, [value("f32", 2), value("f32", 2)]), [value("f32", 3)]);
+
+// ./test/core/loop.wast:518
+assert_return(() => invoke($0, `nesting`, [value("f32", 2), value("f32", 3)]), [value("f32", 4)]);
+
+// ./test/core/loop.wast:519
+assert_return(
+  () => invoke($0, `nesting`, [value("f32", 7), value("f32", 4)]),
+  [value("f32", 10.309524)],
+);
+
+// ./test/core/loop.wast:520
+assert_return(
+  () => invoke($0, `nesting`, [value("f32", 7), value("f32", 100)]),
+  [value("f32", 4381.548)],
+);
+
+// ./test/core/loop.wast:521
+assert_return(() => invoke($0, `nesting`, [value("f32", 7), value("f32", 101)]), [value("f32", 2601)]);
+
+// ./test/core/loop.wast:523
+assert_return(() => invoke($0, `type-use`, []), []);
+
+// ./test/core/loop.wast:525
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (loop (type $$sig) (result i32) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:532
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (loop (param i32) (type $$sig) (result i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:539
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (loop (param i32) (result i32) (type $$sig))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:546
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (loop (result i32) (type $$sig) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:553
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (loop (result i32) (param i32) (type $$sig))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:560
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (loop (result i32) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:567
+assert_malformed(
+  () => instantiate(`(func (i32.const 0) (loop (param $$x i32) (drop))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:571
+assert_malformed(
+  () => instantiate(`(type $$sig (func)) (func (loop (type $$sig) (result i32) (i32.const 0)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/loop.wast:578
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (loop (type $$sig) (result i32) (i32.const 0)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/loop.wast:585
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32) (result i32))) (func (i32.const 0) (loop (type $$sig) (param i32) (drop)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/loop.wast:592
+assert_malformed(
+  () => instantiate(`(type $$sig (func (param i32 i32) (result i32))) (func (i32.const 0) (loop (type $$sig) (param i32) (result i32)) (unreachable)) `),
+  `inline function type`,
+);
+
+// ./test/core/loop.wast:600
+assert_invalid(
+  () => instantiate(`(module
+    (type $$sig (func))
+    (func (loop (type $$sig) (i32.const 0)))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:608
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i32 (result i32) (loop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:612
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-i64 (result i64) (loop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:616
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f32 (result f32) (loop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:620
+assert_invalid(
+  () => instantiate(`(module (func $$type-empty-f64 (result f64) (loop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:625
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-void
+    (loop (i32.const 1))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:631
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-void
+    (loop (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:637
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-num (result i32)
+    (loop (result i32))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:643
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-nums (result i32 i32)
+    (loop (result i32 i32))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:649
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-num (result i32)
+    (loop (result i32) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:655
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-nums (result i32 i32)
+    (loop (result i32 i32) (nop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:661
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-num (result i32)
+    (loop (result i32) (f32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:667
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-nums (result i32 i32)
+    (loop (result i32 i32) (i32.const 0))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:673
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-partial-vs-nums (result i32 i32)
+    (i32.const 1) (loop (result i32 i32) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:679
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-nums-vs-num (result i32)
+    (loop (result i32) (i32.const 1) (i32.const 2))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:685
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-unreached-select (result i32)
+    (loop (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:692
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-in-block
+      (i32.const 0)
+      (block (loop (result i32)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:701
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-in-loop
+      (i32.const 0)
+      (loop (loop (result i32)) (drop))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:710
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (loop (result i32)) (drop)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:720
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-num
+    (loop (param i32) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:726
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (loop (param i32 f64) (drop) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:732
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (f32.const 0) (loop (param i32) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:738
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (f32.const 0) (loop (param f32 i32) (drop) (drop))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:744
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-nested-void-vs-num
+    (block (loop (param i32) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:750
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-void-vs-nums
+    (block (loop (param i32 f64) (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:756
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-num
+    (block (f32.const 0) (loop (param i32) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:762
+assert_invalid(
+  () => instantiate(`(module (func $$type-param-num-vs-nums
+    (block (f32.const 0) (loop (param f32 i32) (drop) (drop)))
+  ))`),
+  `type mismatch`,
+);
+
+// ./test/core/loop.wast:769
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) loop (param $$x i32) end) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:773
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) (loop (param $$x i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/loop.wast:778
+assert_malformed(() => instantiate(`(func loop end $$l) `), `mismatching label`);
+
+// ./test/core/loop.wast:782
+assert_malformed(() => instantiate(`(func loop $$a end $$l) `), `mismatching label`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory.wast.js
new file mode 100644
index 0000000000..831bb26d69
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory.wast.js
@@ -0,0 +1,399 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory.wast
+
+// ./test/core/memory.wast:3
+let $0 = instantiate(`(module (memory 0))`);
+
+// ./test/core/memory.wast:4
+let $1 = instantiate(`(module (memory 1))`);
+
+// ./test/core/memory.wast:5
+let $2 = instantiate(`(module (memory 0 0))`);
+
+// ./test/core/memory.wast:6
+let $3 = instantiate(`(module (memory 0 1))`);
+
+// ./test/core/memory.wast:7
+let $4 = instantiate(`(module (memory 1 256))`);
+
+// ./test/core/memory.wast:8
+let $5 = instantiate(`(module (memory 0 65536))`);
+
+// ./test/core/memory.wast:10
+assert_invalid(() => instantiate(`(module (memory 0) (memory 0))`), `multiple memories`);
+
+// ./test/core/memory.wast:11
+assert_invalid(
+  () => instantiate(`(module (memory (import "spectest" "memory") 0) (memory 0))`),
+  `multiple memories`,
+);
+
+// ./test/core/memory.wast:13
+let $6 = instantiate(`(module (memory (data)) (func (export "memsize") (result i32) (memory.size)))`);
+
+// ./test/core/memory.wast:14
+assert_return(() => invoke($6, `memsize`, []), [value("i32", 0)]);
+
+// ./test/core/memory.wast:15
+let $7 = instantiate(`(module (memory (data "")) (func (export "memsize") (result i32) (memory.size)))`);
+
+// ./test/core/memory.wast:16
+assert_return(() => invoke($7, `memsize`, []), [value("i32", 0)]);
+
+// ./test/core/memory.wast:17
+let $8 = instantiate(`(module (memory (data "x")) (func (export "memsize") (result i32) (memory.size)))`);
+
+// ./test/core/memory.wast:18
+assert_return(() => invoke($8, `memsize`, []), [value("i32", 1)]);
+
+// ./test/core/memory.wast:20
+assert_invalid(() => instantiate(`(module (data (i32.const 0)))`), `unknown memory`);
+
+// ./test/core/memory.wast:21
+assert_invalid(() => instantiate(`(module (data (i32.const 0) ""))`), `unknown memory`);
+
+// ./test/core/memory.wast:22
+assert_invalid(() => instantiate(`(module (data (i32.const 0) "x"))`), `unknown memory`);
+
+// ./test/core/memory.wast:24
+assert_invalid(
+  () => instantiate(`(module (func (drop (f32.load (i32.const 0)))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory.wast:28
+assert_invalid(
+  () => instantiate(`(module (func (f32.store (i32.const 0) (f32.const 0))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory.wast:32
+assert_invalid(
+  () => instantiate(`(module (func (drop (i32.load8_s (i32.const 0)))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory.wast:36
+assert_invalid(
+  () => instantiate(`(module (func (i32.store8 (i32.const 0) (i32.const 0))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory.wast:40
+assert_invalid(
+  () => instantiate(`(module (func (drop (memory.size))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory.wast:44
+assert_invalid(
+  () => instantiate(`(module (func (drop (memory.grow (i32.const 0)))))`),
+  `unknown memory`,
+);
+
+// ./test/core/memory.wast:50
+assert_invalid(
+  () => instantiate(`(module (memory 1 0))`),
+  `size minimum must not be greater than maximum`,
+);
+
+// ./test/core/memory.wast:54
+assert_invalid(
+  () => instantiate(`(module (memory 65537))`),
+  `memory size must be at most 65536 pages (4GiB)`,
+);
+
+// ./test/core/memory.wast:58
+assert_invalid(
+  () => instantiate(`(module (memory 2147483648))`),
+  `memory size must be at most 65536 pages (4GiB)`,
+);
+
+// ./test/core/memory.wast:62
+assert_invalid(
+  () => instantiate(`(module (memory 4294967295))`),
+  `memory size must be at most 65536 pages (4GiB)`,
+);
+
+// ./test/core/memory.wast:66
+assert_invalid(
+  () => instantiate(`(module (memory 0 65537))`),
+  `memory size must be at most 65536 pages (4GiB)`,
+);
+
+// ./test/core/memory.wast:70
+assert_invalid(
+  () => instantiate(`(module (memory 0 2147483648))`),
+  `memory size must be at most 65536 pages (4GiB)`,
+);
+
+// ./test/core/memory.wast:74
+assert_invalid(
+  () => instantiate(`(module (memory 0 4294967295))`),
+  `memory size must be at most 65536 pages (4GiB)`,
+);
+
+// ./test/core/memory.wast:79
+assert_malformed(
+  () => instantiate(`(memory 0x1_0000_0000) `),
+  `i32 constant out of range`,
+);
+
+// ./test/core/memory.wast:83
+assert_malformed(
+  () => instantiate(`(memory 0x1_0000_0000 0x1_0000_0000) `),
+  `i32 constant out of range`,
+);
+
+// ./test/core/memory.wast:87
+assert_malformed(
+  () => instantiate(`(memory 0 0x1_0000_0000) `),
+  `i32 constant out of range`,
+);
+
+// ./test/core/memory.wast:92
+let $9 = instantiate(`(module
+  (memory 1)
+  (data (i32.const 0) "ABC\\a7D") (data (i32.const 20) "WASM")
+
+  ;; Data section
+  (func (export "data") (result i32)
+    (i32.and
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 0)) (i32.const 65))
+          (i32.eq (i32.load8_u (i32.const 3)) (i32.const 167))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 6)) (i32.const 0))
+          (i32.eq (i32.load8_u (i32.const 19)) (i32.const 0))
+        )
+      )
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 20)) (i32.const 87))
+          (i32.eq (i32.load8_u (i32.const 23)) (i32.const 77))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 24)) (i32.const 0))
+          (i32.eq (i32.load8_u (i32.const 1023)) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  ;; Memory cast
+  (func (export "cast") (result f64)
+    (i64.store (i32.const 8) (i64.const -12345))
+    (if
+      (f64.eq
+        (f64.load (i32.const 8))
+        (f64.reinterpret_i64 (i64.const -12345))
+      )
+      (then (return (f64.const 0)))
+    )
+    (i64.store align=1 (i32.const 9) (i64.const 0))
+    (i32.store16 align=1 (i32.const 15) (i32.const 16453))
+    (f64.load align=1 (i32.const 9))
+  )
+
+  ;; Sign and zero extending memory loads
+  (func (export "i32_load8_s") (param $$i i32) (result i32)
+	(i32.store8 (i32.const 8) (local.get $$i))
+	(i32.load8_s (i32.const 8))
+  )
+  (func (export "i32_load8_u") (param $$i i32) (result i32)
+	(i32.store8 (i32.const 8) (local.get $$i))
+	(i32.load8_u (i32.const 8))
+  )
+  (func (export "i32_load16_s") (param $$i i32) (result i32)
+	(i32.store16 (i32.const 8) (local.get $$i))
+	(i32.load16_s (i32.const 8))
+  )
+  (func (export "i32_load16_u") (param $$i i32) (result i32)
+	(i32.store16 (i32.const 8) (local.get $$i))
+	(i32.load16_u (i32.const 8))
+  )
+  (func (export "i64_load8_s") (param $$i i64) (result i64)
+	(i64.store8 (i32.const 8) (local.get $$i))
+	(i64.load8_s (i32.const 8))
+  )
+  (func (export "i64_load8_u") (param $$i i64) (result i64)
+	(i64.store8 (i32.const 8) (local.get $$i))
+	(i64.load8_u (i32.const 8))
+  )
+  (func (export "i64_load16_s") (param $$i i64) (result i64)
+	(i64.store16 (i32.const 8) (local.get $$i))
+	(i64.load16_s (i32.const 8))
+  )
+  (func (export "i64_load16_u") (param $$i i64) (result i64)
+	(i64.store16 (i32.const 8) (local.get $$i))
+	(i64.load16_u (i32.const 8))
+  )
+  (func (export "i64_load32_s") (param $$i i64) (result i64)
+	(i64.store32 (i32.const 8) (local.get $$i))
+	(i64.load32_s (i32.const 8))
+  )
+  (func (export "i64_load32_u") (param $$i i64) (result i64)
+	(i64.store32 (i32.const 8) (local.get $$i))
+	(i64.load32_u (i32.const 8))
+  )
+)`);
+
+// ./test/core/memory.wast:180
+assert_return(() => invoke($9, `data`, []), [value("i32", 1)]);
+
+// ./test/core/memory.wast:181
+assert_return(() => invoke($9, `cast`, []), [value("f64", 42)]);
+
+// ./test/core/memory.wast:183
+assert_return(() => invoke($9, `i32_load8_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/memory.wast:184
+assert_return(() => invoke($9, `i32_load8_u`, [-1]), [value("i32", 255)]);
+
+// ./test/core/memory.wast:185
+assert_return(() => invoke($9, `i32_load16_s`, [-1]), [value("i32", -1)]);
+
+// ./test/core/memory.wast:186
+assert_return(() => invoke($9, `i32_load16_u`, [-1]), [value("i32", 65535)]);
+
+// ./test/core/memory.wast:188
+assert_return(() => invoke($9, `i32_load8_s`, [100]), [value("i32", 100)]);
+
+// ./test/core/memory.wast:189
+assert_return(() => invoke($9, `i32_load8_u`, [200]), [value("i32", 200)]);
+
+// ./test/core/memory.wast:190
+assert_return(() => invoke($9, `i32_load16_s`, [20000]), [value("i32", 20000)]);
+
+// ./test/core/memory.wast:191
+assert_return(() => invoke($9, `i32_load16_u`, [40000]), [value("i32", 40000)]);
+
+// ./test/core/memory.wast:193
+assert_return(() => invoke($9, `i32_load8_s`, [-19110589]), [value("i32", 67)]);
+
+// ./test/core/memory.wast:194
+assert_return(() => invoke($9, `i32_load8_s`, [878104047]), [value("i32", -17)]);
+
+// ./test/core/memory.wast:195
+assert_return(() => invoke($9, `i32_load8_u`, [-19110589]), [value("i32", 67)]);
+
+// ./test/core/memory.wast:196
+assert_return(() => invoke($9, `i32_load8_u`, [878104047]), [value("i32", 239)]);
+
+// ./test/core/memory.wast:197
+assert_return(() => invoke($9, `i32_load16_s`, [-19110589]), [value("i32", 25923)]);
+
+// ./test/core/memory.wast:198
+assert_return(() => invoke($9, `i32_load16_s`, [878104047]), [value("i32", -12817)]);
+
+// ./test/core/memory.wast:199
+assert_return(() => invoke($9, `i32_load16_u`, [-19110589]), [value("i32", 25923)]);
+
+// ./test/core/memory.wast:200
+assert_return(() => invoke($9, `i32_load16_u`, [878104047]), [value("i32", 52719)]);
+
+// ./test/core/memory.wast:202
+assert_return(() => invoke($9, `i64_load8_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/memory.wast:203
+assert_return(() => invoke($9, `i64_load8_u`, [-1n]), [value("i64", 255n)]);
+
+// ./test/core/memory.wast:204
+assert_return(() => invoke($9, `i64_load16_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/memory.wast:205
+assert_return(() => invoke($9, `i64_load16_u`, [-1n]), [value("i64", 65535n)]);
+
+// ./test/core/memory.wast:206
+assert_return(() => invoke($9, `i64_load32_s`, [-1n]), [value("i64", -1n)]);
+
+// ./test/core/memory.wast:207
+assert_return(() => invoke($9, `i64_load32_u`, [-1n]), [value("i64", 4294967295n)]);
+
+// ./test/core/memory.wast:209
+assert_return(() => invoke($9, `i64_load8_s`, [100n]), [value("i64", 100n)]);
+
+// ./test/core/memory.wast:210
+assert_return(() => invoke($9, `i64_load8_u`, [200n]), [value("i64", 200n)]);
+
+// ./test/core/memory.wast:211
+assert_return(() => invoke($9, `i64_load16_s`, [20000n]), [value("i64", 20000n)]);
+
+// ./test/core/memory.wast:212
+assert_return(() => invoke($9, `i64_load16_u`, [40000n]), [value("i64", 40000n)]);
+
+// ./test/core/memory.wast:213
+assert_return(() => invoke($9, `i64_load32_s`, [20000n]), [value("i64", 20000n)]);
+
+// ./test/core/memory.wast:214
+assert_return(() => invoke($9, `i64_load32_u`, [40000n]), [value("i64", 40000n)]);
+
+// ./test/core/memory.wast:216
+assert_return(() => invoke($9, `i64_load8_s`, [-81985529755441853n]), [value("i64", 67n)]);
+
+// ./test/core/memory.wast:217
+assert_return(() => invoke($9, `i64_load8_s`, [3771275841602506223n]), [value("i64", -17n)]);
+
+// ./test/core/memory.wast:218
+assert_return(() => invoke($9, `i64_load8_u`, [-81985529755441853n]), [value("i64", 67n)]);
+
+// ./test/core/memory.wast:219
+assert_return(() => invoke($9, `i64_load8_u`, [3771275841602506223n]), [value("i64", 239n)]);
+
+// ./test/core/memory.wast:220
+assert_return(() => invoke($9, `i64_load16_s`, [-81985529755441853n]), [value("i64", 25923n)]);
+
+// ./test/core/memory.wast:221
+assert_return(() => invoke($9, `i64_load16_s`, [3771275841602506223n]), [value("i64", -12817n)]);
+
+// ./test/core/memory.wast:222
+assert_return(() => invoke($9, `i64_load16_u`, [-81985529755441853n]), [value("i64", 25923n)]);
+
+// ./test/core/memory.wast:223
+assert_return(() => invoke($9, `i64_load16_u`, [3771275841602506223n]), [value("i64", 52719n)]);
+
+// ./test/core/memory.wast:224
+assert_return(() => invoke($9, `i64_load32_s`, [-81985529755441853n]), [value("i64", 1446274371n)]);
+
+// ./test/core/memory.wast:225
+assert_return(() => invoke($9, `i64_load32_s`, [3771275841602506223n]), [value("i64", -1732588049n)]);
+
+// ./test/core/memory.wast:226
+assert_return(() => invoke($9, `i64_load32_u`, [-81985529755441853n]), [value("i64", 1446274371n)]);
+
+// ./test/core/memory.wast:227
+assert_return(() => invoke($9, `i64_load32_u`, [3771275841602506223n]), [value("i64", 2562379247n)]);
+
+// ./test/core/memory.wast:231
+assert_malformed(
+  () => instantiate(`(memory $$foo 1) (memory $$foo 1) `),
+  `duplicate memory`,
+);
+
+// ./test/core/memory.wast:235
+assert_malformed(
+  () => instantiate(`(import "" "" (memory $$foo 1)) (memory $$foo 1) `),
+  `duplicate memory`,
+);
+
+// ./test/core/memory.wast:239
+assert_malformed(
+  () => instantiate(`(import "" "" (memory $$foo 1)) (import "" "" (memory $$foo 1)) `),
+  `duplicate memory`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory_copy.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory_copy.wast.js
new file mode 100644
index 0000000000..dbd81aacd7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory_copy.wast.js
@@ -0,0 +1,14165 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_copy.wast
+
+// ./test/core/memory_copy.wast:6
+let $0 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:15
+invoke($0, `test`, []);
+
+// ./test/core/memory_copy.wast:17
+assert_return(() => invoke($0, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:18
+assert_return(() => invoke($0, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:19
+assert_return(() => invoke($0, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:20
+assert_return(() => invoke($0, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:21
+assert_return(() => invoke($0, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:22
+assert_return(() => invoke($0, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:23
+assert_return(() => invoke($0, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:24
+assert_return(() => invoke($0, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:25
+assert_return(() => invoke($0, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:26
+assert_return(() => invoke($0, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:27
+assert_return(() => invoke($0, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:28
+assert_return(() => invoke($0, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:29
+assert_return(() => invoke($0, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:30
+assert_return(() => invoke($0, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:31
+assert_return(() => invoke($0, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:32
+assert_return(() => invoke($0, `load8_u`, [15]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:33
+assert_return(() => invoke($0, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:34
+assert_return(() => invoke($0, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:35
+assert_return(() => invoke($0, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:36
+assert_return(() => invoke($0, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:37
+assert_return(() => invoke($0, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:38
+assert_return(() => invoke($0, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:39
+assert_return(() => invoke($0, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:40
+assert_return(() => invoke($0, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:41
+assert_return(() => invoke($0, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:42
+assert_return(() => invoke($0, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:43
+assert_return(() => invoke($0, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:44
+assert_return(() => invoke($0, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:45
+assert_return(() => invoke($0, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:46
+assert_return(() => invoke($0, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:48
+let $1 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:57
+invoke($1, `test`, []);
+
+// ./test/core/memory_copy.wast:59
+assert_return(() => invoke($1, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:60
+assert_return(() => invoke($1, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:61
+assert_return(() => invoke($1, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:62
+assert_return(() => invoke($1, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:63
+assert_return(() => invoke($1, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:64
+assert_return(() => invoke($1, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:65
+assert_return(() => invoke($1, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:66
+assert_return(() => invoke($1, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:67
+assert_return(() => invoke($1, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:68
+assert_return(() => invoke($1, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:69
+assert_return(() => invoke($1, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:70
+assert_return(() => invoke($1, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:71
+assert_return(() => invoke($1, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:72
+assert_return(() => invoke($1, `load8_u`, [13]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:73
+assert_return(() => invoke($1, `load8_u`, [14]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:74
+assert_return(() => invoke($1, `load8_u`, [15]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:75
+assert_return(() => invoke($1, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:76
+assert_return(() => invoke($1, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:77
+assert_return(() => invoke($1, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:78
+assert_return(() => invoke($1, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:79
+assert_return(() => invoke($1, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:80
+assert_return(() => invoke($1, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:81
+assert_return(() => invoke($1, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:82
+assert_return(() => invoke($1, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:83
+assert_return(() => invoke($1, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:84
+assert_return(() => invoke($1, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:85
+assert_return(() => invoke($1, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:86
+assert_return(() => invoke($1, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:87
+assert_return(() => invoke($1, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:88
+assert_return(() => invoke($1, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:90
+let $2 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:99
+invoke($2, `test`, []);
+
+// ./test/core/memory_copy.wast:101
+assert_return(() => invoke($2, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:102
+assert_return(() => invoke($2, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:103
+assert_return(() => invoke($2, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:104
+assert_return(() => invoke($2, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:105
+assert_return(() => invoke($2, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:106
+assert_return(() => invoke($2, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:107
+assert_return(() => invoke($2, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:108
+assert_return(() => invoke($2, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:109
+assert_return(() => invoke($2, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:110
+assert_return(() => invoke($2, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:111
+assert_return(() => invoke($2, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:112
+assert_return(() => invoke($2, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:113
+assert_return(() => invoke($2, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:114
+assert_return(() => invoke($2, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:115
+assert_return(() => invoke($2, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:116
+assert_return(() => invoke($2, `load8_u`, [15]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:117
+assert_return(() => invoke($2, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:118
+assert_return(() => invoke($2, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:119
+assert_return(() => invoke($2, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:120
+assert_return(() => invoke($2, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:121
+assert_return(() => invoke($2, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:122
+assert_return(() => invoke($2, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:123
+assert_return(() => invoke($2, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:124
+assert_return(() => invoke($2, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:125
+assert_return(() => invoke($2, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:126
+assert_return(() => invoke($2, `load8_u`, [25]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:127
+assert_return(() => invoke($2, `load8_u`, [26]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:128
+assert_return(() => invoke($2, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:129
+assert_return(() => invoke($2, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:130
+assert_return(() => invoke($2, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:132
+let $3 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:141
+invoke($3, `test`, []);
+
+// ./test/core/memory_copy.wast:143
+assert_return(() => invoke($3, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:144
+assert_return(() => invoke($3, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:145
+assert_return(() => invoke($3, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:146
+assert_return(() => invoke($3, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:147
+assert_return(() => invoke($3, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:148
+assert_return(() => invoke($3, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:149
+assert_return(() => invoke($3, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:150
+assert_return(() => invoke($3, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:151
+assert_return(() => invoke($3, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:152
+assert_return(() => invoke($3, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:153
+assert_return(() => invoke($3, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:154
+assert_return(() => invoke($3, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:155
+assert_return(() => invoke($3, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:156
+assert_return(() => invoke($3, `load8_u`, [13]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:157
+assert_return(() => invoke($3, `load8_u`, [14]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:158
+assert_return(() => invoke($3, `load8_u`, [15]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:159
+assert_return(() => invoke($3, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:160
+assert_return(() => invoke($3, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:161
+assert_return(() => invoke($3, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:162
+assert_return(() => invoke($3, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:163
+assert_return(() => invoke($3, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:164
+assert_return(() => invoke($3, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:165
+assert_return(() => invoke($3, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:166
+assert_return(() => invoke($3, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:167
+assert_return(() => invoke($3, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:168
+assert_return(() => invoke($3, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:169
+assert_return(() => invoke($3, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:170
+assert_return(() => invoke($3, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:171
+assert_return(() => invoke($3, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:172
+assert_return(() => invoke($3, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:174
+let $4 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:183
+invoke($4, `test`, []);
+
+// ./test/core/memory_copy.wast:185
+assert_return(() => invoke($4, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:186
+assert_return(() => invoke($4, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:187
+assert_return(() => invoke($4, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:188
+assert_return(() => invoke($4, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:189
+assert_return(() => invoke($4, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:190
+assert_return(() => invoke($4, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:191
+assert_return(() => invoke($4, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:192
+assert_return(() => invoke($4, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:193
+assert_return(() => invoke($4, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:194
+assert_return(() => invoke($4, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:195
+assert_return(() => invoke($4, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:196
+assert_return(() => invoke($4, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:197
+assert_return(() => invoke($4, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:198
+assert_return(() => invoke($4, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:199
+assert_return(() => invoke($4, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:200
+assert_return(() => invoke($4, `load8_u`, [15]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:201
+assert_return(() => invoke($4, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:202
+assert_return(() => invoke($4, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:203
+assert_return(() => invoke($4, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:204
+assert_return(() => invoke($4, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:205
+assert_return(() => invoke($4, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:206
+assert_return(() => invoke($4, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:207
+assert_return(() => invoke($4, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:208
+assert_return(() => invoke($4, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:209
+assert_return(() => invoke($4, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:210
+assert_return(() => invoke($4, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:211
+assert_return(() => invoke($4, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:212
+assert_return(() => invoke($4, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:213
+assert_return(() => invoke($4, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:214
+assert_return(() => invoke($4, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:216
+let $5 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:225
+invoke($5, `test`, []);
+
+// ./test/core/memory_copy.wast:227
+assert_return(() => invoke($5, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:228
+assert_return(() => invoke($5, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:229
+assert_return(() => invoke($5, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:230
+assert_return(() => invoke($5, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:231
+assert_return(() => invoke($5, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:232
+assert_return(() => invoke($5, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:233
+assert_return(() => invoke($5, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:234
+assert_return(() => invoke($5, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:235
+assert_return(() => invoke($5, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:236
+assert_return(() => invoke($5, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:237
+assert_return(() => invoke($5, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:238
+assert_return(() => invoke($5, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:239
+assert_return(() => invoke($5, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:240
+assert_return(() => invoke($5, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:241
+assert_return(() => invoke($5, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:242
+assert_return(() => invoke($5, `load8_u`, [15]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:243
+assert_return(() => invoke($5, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:244
+assert_return(() => invoke($5, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:245
+assert_return(() => invoke($5, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:246
+assert_return(() => invoke($5, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:247
+assert_return(() => invoke($5, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:248
+assert_return(() => invoke($5, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:249
+assert_return(() => invoke($5, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:250
+assert_return(() => invoke($5, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:251
+assert_return(() => invoke($5, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:252
+assert_return(() => invoke($5, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:253
+assert_return(() => invoke($5, `load8_u`, [26]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:254
+assert_return(() => invoke($5, `load8_u`, [27]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:255
+assert_return(() => invoke($5, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:256
+assert_return(() => invoke($5, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:258
+let $6 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:267
+invoke($6, `test`, []);
+
+// ./test/core/memory_copy.wast:269
+assert_return(() => invoke($6, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:270
+assert_return(() => invoke($6, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:271
+assert_return(() => invoke($6, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:272
+assert_return(() => invoke($6, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:273
+assert_return(() => invoke($6, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:274
+assert_return(() => invoke($6, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:275
+assert_return(() => invoke($6, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:276
+assert_return(() => invoke($6, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:277
+assert_return(() => invoke($6, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:278
+assert_return(() => invoke($6, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:279
+assert_return(() => invoke($6, `load8_u`, [10]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:280
+assert_return(() => invoke($6, `load8_u`, [11]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:281
+assert_return(() => invoke($6, `load8_u`, [12]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:282
+assert_return(() => invoke($6, `load8_u`, [13]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:283
+assert_return(() => invoke($6, `load8_u`, [14]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:284
+assert_return(() => invoke($6, `load8_u`, [15]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:285
+assert_return(() => invoke($6, `load8_u`, [16]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:286
+assert_return(() => invoke($6, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:287
+assert_return(() => invoke($6, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:288
+assert_return(() => invoke($6, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:289
+assert_return(() => invoke($6, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:290
+assert_return(() => invoke($6, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:291
+assert_return(() => invoke($6, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:292
+assert_return(() => invoke($6, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:293
+assert_return(() => invoke($6, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:294
+assert_return(() => invoke($6, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:295
+assert_return(() => invoke($6, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:296
+assert_return(() => invoke($6, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:297
+assert_return(() => invoke($6, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:298
+assert_return(() => invoke($6, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:300
+let $7 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (func (export "test")
+    (memory.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:309
+invoke($7, `test`, []);
+
+// ./test/core/memory_copy.wast:311
+assert_return(() => invoke($7, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:312
+assert_return(() => invoke($7, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:313
+assert_return(() => invoke($7, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:314
+assert_return(() => invoke($7, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:315
+assert_return(() => invoke($7, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:316
+assert_return(() => invoke($7, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:317
+assert_return(() => invoke($7, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:318
+assert_return(() => invoke($7, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:319
+assert_return(() => invoke($7, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:320
+assert_return(() => invoke($7, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:321
+assert_return(() => invoke($7, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:322
+assert_return(() => invoke($7, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:323
+assert_return(() => invoke($7, `load8_u`, [12]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:324
+assert_return(() => invoke($7, `load8_u`, [13]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:325
+assert_return(() => invoke($7, `load8_u`, [14]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:326
+assert_return(() => invoke($7, `load8_u`, [15]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:327
+assert_return(() => invoke($7, `load8_u`, [16]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:328
+assert_return(() => invoke($7, `load8_u`, [17]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:329
+assert_return(() => invoke($7, `load8_u`, [18]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:330
+assert_return(() => invoke($7, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:331
+assert_return(() => invoke($7, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:332
+assert_return(() => invoke($7, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:333
+assert_return(() => invoke($7, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:334
+assert_return(() => invoke($7, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:335
+assert_return(() => invoke($7, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:336
+assert_return(() => invoke($7, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:337
+assert_return(() => invoke($7, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:338
+assert_return(() => invoke($7, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:339
+assert_return(() => invoke($7, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:340
+assert_return(() => invoke($7, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:342
+let $8 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:350
+assert_trap(() => invoke($8, `run`, [65516, 0, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:353
+assert_return(() => invoke($8, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:354
+assert_return(() => invoke($8, `load8_u`, [1]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:355
+assert_return(() => invoke($8, `load8_u`, [2]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:356
+assert_return(() => invoke($8, `load8_u`, [3]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:357
+assert_return(() => invoke($8, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:358
+assert_return(() => invoke($8, `load8_u`, [5]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:359
+assert_return(() => invoke($8, `load8_u`, [6]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:360
+assert_return(() => invoke($8, `load8_u`, [7]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:361
+assert_return(() => invoke($8, `load8_u`, [8]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:362
+assert_return(() => invoke($8, `load8_u`, [9]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:363
+assert_return(() => invoke($8, `load8_u`, [10]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:364
+assert_return(() => invoke($8, `load8_u`, [11]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:365
+assert_return(() => invoke($8, `load8_u`, [12]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:366
+assert_return(() => invoke($8, `load8_u`, [13]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:367
+assert_return(() => invoke($8, `load8_u`, [14]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:368
+assert_return(() => invoke($8, `load8_u`, [15]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:369
+assert_return(() => invoke($8, `load8_u`, [16]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:370
+assert_return(() => invoke($8, `load8_u`, [17]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:371
+assert_return(() => invoke($8, `load8_u`, [18]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:372
+assert_return(() => invoke($8, `load8_u`, [19]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:373
+assert_return(() => invoke($8, `load8_u`, [218]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:374
+assert_return(() => invoke($8, `load8_u`, [417]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:375
+assert_return(() => invoke($8, `load8_u`, [616]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:376
+assert_return(() => invoke($8, `load8_u`, [815]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:377
+assert_return(() => invoke($8, `load8_u`, [1014]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:378
+assert_return(() => invoke($8, `load8_u`, [1213]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:379
+assert_return(() => invoke($8, `load8_u`, [1412]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:380
+assert_return(() => invoke($8, `load8_u`, [1611]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:381
+assert_return(() => invoke($8, `load8_u`, [1810]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:382
+assert_return(() => invoke($8, `load8_u`, [2009]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:383
+assert_return(() => invoke($8, `load8_u`, [2208]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:384
+assert_return(() => invoke($8, `load8_u`, [2407]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:385
+assert_return(() => invoke($8, `load8_u`, [2606]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:386
+assert_return(() => invoke($8, `load8_u`, [2805]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:387
+assert_return(() => invoke($8, `load8_u`, [3004]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:388
+assert_return(() => invoke($8, `load8_u`, [3203]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:389
+assert_return(() => invoke($8, `load8_u`, [3402]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:390
+assert_return(() => invoke($8, `load8_u`, [3601]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:391
+assert_return(() => invoke($8, `load8_u`, [3800]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:392
+assert_return(() => invoke($8, `load8_u`, [3999]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:393
+assert_return(() => invoke($8, `load8_u`, [4198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:394
+assert_return(() => invoke($8, `load8_u`, [4397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:395
+assert_return(() => invoke($8, `load8_u`, [4596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:396
+assert_return(() => invoke($8, `load8_u`, [4795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:397
+assert_return(() => invoke($8, `load8_u`, [4994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:398
+assert_return(() => invoke($8, `load8_u`, [5193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:399
+assert_return(() => invoke($8, `load8_u`, [5392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:400
+assert_return(() => invoke($8, `load8_u`, [5591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:401
+assert_return(() => invoke($8, `load8_u`, [5790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:402
+assert_return(() => invoke($8, `load8_u`, [5989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:403
+assert_return(() => invoke($8, `load8_u`, [6188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:404
+assert_return(() => invoke($8, `load8_u`, [6387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:405
+assert_return(() => invoke($8, `load8_u`, [6586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:406
+assert_return(() => invoke($8, `load8_u`, [6785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:407
+assert_return(() => invoke($8, `load8_u`, [6984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:408
+assert_return(() => invoke($8, `load8_u`, [7183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:409
+assert_return(() => invoke($8, `load8_u`, [7382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:410
+assert_return(() => invoke($8, `load8_u`, [7581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:411
+assert_return(() => invoke($8, `load8_u`, [7780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:412
+assert_return(() => invoke($8, `load8_u`, [7979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:413
+assert_return(() => invoke($8, `load8_u`, [8178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:414
+assert_return(() => invoke($8, `load8_u`, [8377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:415
+assert_return(() => invoke($8, `load8_u`, [8576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:416
+assert_return(() => invoke($8, `load8_u`, [8775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:417
+assert_return(() => invoke($8, `load8_u`, [8974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:418
+assert_return(() => invoke($8, `load8_u`, [9173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:419
+assert_return(() => invoke($8, `load8_u`, [9372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:420
+assert_return(() => invoke($8, `load8_u`, [9571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:421
+assert_return(() => invoke($8, `load8_u`, [9770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:422
+assert_return(() => invoke($8, `load8_u`, [9969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:423
+assert_return(() => invoke($8, `load8_u`, [10168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:424
+assert_return(() => invoke($8, `load8_u`, [10367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:425
+assert_return(() => invoke($8, `load8_u`, [10566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:426
+assert_return(() => invoke($8, `load8_u`, [10765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:427
+assert_return(() => invoke($8, `load8_u`, [10964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:428
+assert_return(() => invoke($8, `load8_u`, [11163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:429
+assert_return(() => invoke($8, `load8_u`, [11362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:430
+assert_return(() => invoke($8, `load8_u`, [11561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:431
+assert_return(() => invoke($8, `load8_u`, [11760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:432
+assert_return(() => invoke($8, `load8_u`, [11959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:433
+assert_return(() => invoke($8, `load8_u`, [12158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:434
+assert_return(() => invoke($8, `load8_u`, [12357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:435
+assert_return(() => invoke($8, `load8_u`, [12556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:436
+assert_return(() => invoke($8, `load8_u`, [12755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:437
+assert_return(() => invoke($8, `load8_u`, [12954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:438
+assert_return(() => invoke($8, `load8_u`, [13153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:439
+assert_return(() => invoke($8, `load8_u`, [13352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:440
+assert_return(() => invoke($8, `load8_u`, [13551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:441
+assert_return(() => invoke($8, `load8_u`, [13750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:442
+assert_return(() => invoke($8, `load8_u`, [13949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:443
+assert_return(() => invoke($8, `load8_u`, [14148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:444
+assert_return(() => invoke($8, `load8_u`, [14347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:445
+assert_return(() => invoke($8, `load8_u`, [14546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:446
+assert_return(() => invoke($8, `load8_u`, [14745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:447
+assert_return(() => invoke($8, `load8_u`, [14944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:448
+assert_return(() => invoke($8, `load8_u`, [15143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:449
+assert_return(() => invoke($8, `load8_u`, [15342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:450
+assert_return(() => invoke($8, `load8_u`, [15541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:451
+assert_return(() => invoke($8, `load8_u`, [15740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:452
+assert_return(() => invoke($8, `load8_u`, [15939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:453
+assert_return(() => invoke($8, `load8_u`, [16138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:454
+assert_return(() => invoke($8, `load8_u`, [16337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:455
+assert_return(() => invoke($8, `load8_u`, [16536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:456
+assert_return(() => invoke($8, `load8_u`, [16735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:457
+assert_return(() => invoke($8, `load8_u`, [16934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:458
+assert_return(() => invoke($8, `load8_u`, [17133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:459
+assert_return(() => invoke($8, `load8_u`, [17332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:460
+assert_return(() => invoke($8, `load8_u`, [17531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:461
+assert_return(() => invoke($8, `load8_u`, [17730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:462
+assert_return(() => invoke($8, `load8_u`, [17929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:463
+assert_return(() => invoke($8, `load8_u`, [18128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:464
+assert_return(() => invoke($8, `load8_u`, [18327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:465
+assert_return(() => invoke($8, `load8_u`, [18526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:466
+assert_return(() => invoke($8, `load8_u`, [18725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:467
+assert_return(() => invoke($8, `load8_u`, [18924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:468
+assert_return(() => invoke($8, `load8_u`, [19123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:469
+assert_return(() => invoke($8, `load8_u`, [19322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:470
+assert_return(() => invoke($8, `load8_u`, [19521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:471
+assert_return(() => invoke($8, `load8_u`, [19720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:472
+assert_return(() => invoke($8, `load8_u`, [19919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:473
+assert_return(() => invoke($8, `load8_u`, [20118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:474
+assert_return(() => invoke($8, `load8_u`, [20317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:475
+assert_return(() => invoke($8, `load8_u`, [20516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:476
+assert_return(() => invoke($8, `load8_u`, [20715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:477
+assert_return(() => invoke($8, `load8_u`, [20914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:478
+assert_return(() => invoke($8, `load8_u`, [21113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:479
+assert_return(() => invoke($8, `load8_u`, [21312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:480
+assert_return(() => invoke($8, `load8_u`, [21511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:481
+assert_return(() => invoke($8, `load8_u`, [21710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:482
+assert_return(() => invoke($8, `load8_u`, [21909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:483
+assert_return(() => invoke($8, `load8_u`, [22108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:484
+assert_return(() => invoke($8, `load8_u`, [22307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:485
+assert_return(() => invoke($8, `load8_u`, [22506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:486
+assert_return(() => invoke($8, `load8_u`, [22705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:487
+assert_return(() => invoke($8, `load8_u`, [22904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:488
+assert_return(() => invoke($8, `load8_u`, [23103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:489
+assert_return(() => invoke($8, `load8_u`, [23302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:490
+assert_return(() => invoke($8, `load8_u`, [23501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:491
+assert_return(() => invoke($8, `load8_u`, [23700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:492
+assert_return(() => invoke($8, `load8_u`, [23899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:493
+assert_return(() => invoke($8, `load8_u`, [24098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:494
+assert_return(() => invoke($8, `load8_u`, [24297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:495
+assert_return(() => invoke($8, `load8_u`, [24496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:496
+assert_return(() => invoke($8, `load8_u`, [24695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:497
+assert_return(() => invoke($8, `load8_u`, [24894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:498
+assert_return(() => invoke($8, `load8_u`, [25093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:499
+assert_return(() => invoke($8, `load8_u`, [25292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:500
+assert_return(() => invoke($8, `load8_u`, [25491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:501
+assert_return(() => invoke($8, `load8_u`, [25690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:502
+assert_return(() => invoke($8, `load8_u`, [25889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:503
+assert_return(() => invoke($8, `load8_u`, [26088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:504
+assert_return(() => invoke($8, `load8_u`, [26287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:505
+assert_return(() => invoke($8, `load8_u`, [26486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:506
+assert_return(() => invoke($8, `load8_u`, [26685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:507
+assert_return(() => invoke($8, `load8_u`, [26884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:508
+assert_return(() => invoke($8, `load8_u`, [27083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:509
+assert_return(() => invoke($8, `load8_u`, [27282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:510
+assert_return(() => invoke($8, `load8_u`, [27481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:511
+assert_return(() => invoke($8, `load8_u`, [27680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:512
+assert_return(() => invoke($8, `load8_u`, [27879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:513
+assert_return(() => invoke($8, `load8_u`, [28078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:514
+assert_return(() => invoke($8, `load8_u`, [28277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:515
+assert_return(() => invoke($8, `load8_u`, [28476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:516
+assert_return(() => invoke($8, `load8_u`, [28675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:517
+assert_return(() => invoke($8, `load8_u`, [28874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:518
+assert_return(() => invoke($8, `load8_u`, [29073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:519
+assert_return(() => invoke($8, `load8_u`, [29272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:520
+assert_return(() => invoke($8, `load8_u`, [29471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:521
+assert_return(() => invoke($8, `load8_u`, [29670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:522
+assert_return(() => invoke($8, `load8_u`, [29869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:523
+assert_return(() => invoke($8, `load8_u`, [30068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:524
+assert_return(() => invoke($8, `load8_u`, [30267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:525
+assert_return(() => invoke($8, `load8_u`, [30466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:526
+assert_return(() => invoke($8, `load8_u`, [30665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:527
+assert_return(() => invoke($8, `load8_u`, [30864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:528
+assert_return(() => invoke($8, `load8_u`, [31063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:529
+assert_return(() => invoke($8, `load8_u`, [31262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:530
+assert_return(() => invoke($8, `load8_u`, [31461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:531
+assert_return(() => invoke($8, `load8_u`, [31660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:532
+assert_return(() => invoke($8, `load8_u`, [31859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:533
+assert_return(() => invoke($8, `load8_u`, [32058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:534
+assert_return(() => invoke($8, `load8_u`, [32257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:535
+assert_return(() => invoke($8, `load8_u`, [32456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:536
+assert_return(() => invoke($8, `load8_u`, [32655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:537
+assert_return(() => invoke($8, `load8_u`, [32854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:538
+assert_return(() => invoke($8, `load8_u`, [33053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:539
+assert_return(() => invoke($8, `load8_u`, [33252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:540
+assert_return(() => invoke($8, `load8_u`, [33451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:541
+assert_return(() => invoke($8, `load8_u`, [33650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:542
+assert_return(() => invoke($8, `load8_u`, [33849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:543
+assert_return(() => invoke($8, `load8_u`, [34048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:544
+assert_return(() => invoke($8, `load8_u`, [34247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:545
+assert_return(() => invoke($8, `load8_u`, [34446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:546
+assert_return(() => invoke($8, `load8_u`, [34645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:547
+assert_return(() => invoke($8, `load8_u`, [34844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:548
+assert_return(() => invoke($8, `load8_u`, [35043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:549
+assert_return(() => invoke($8, `load8_u`, [35242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:550
+assert_return(() => invoke($8, `load8_u`, [35441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:551
+assert_return(() => invoke($8, `load8_u`, [35640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:552
+assert_return(() => invoke($8, `load8_u`, [35839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:553
+assert_return(() => invoke($8, `load8_u`, [36038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:554
+assert_return(() => invoke($8, `load8_u`, [36237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:555
+assert_return(() => invoke($8, `load8_u`, [36436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:556
+assert_return(() => invoke($8, `load8_u`, [36635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:557
+assert_return(() => invoke($8, `load8_u`, [36834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:558
+assert_return(() => invoke($8, `load8_u`, [37033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:559
+assert_return(() => invoke($8, `load8_u`, [37232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:560
+assert_return(() => invoke($8, `load8_u`, [37431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:561
+assert_return(() => invoke($8, `load8_u`, [37630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:562
+assert_return(() => invoke($8, `load8_u`, [37829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:563
+assert_return(() => invoke($8, `load8_u`, [38028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:564
+assert_return(() => invoke($8, `load8_u`, [38227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:565
+assert_return(() => invoke($8, `load8_u`, [38426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:566
+assert_return(() => invoke($8, `load8_u`, [38625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:567
+assert_return(() => invoke($8, `load8_u`, [38824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:568
+assert_return(() => invoke($8, `load8_u`, [39023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:569
+assert_return(() => invoke($8, `load8_u`, [39222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:570
+assert_return(() => invoke($8, `load8_u`, [39421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:571
+assert_return(() => invoke($8, `load8_u`, [39620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:572
+assert_return(() => invoke($8, `load8_u`, [39819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:573
+assert_return(() => invoke($8, `load8_u`, [40018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:574
+assert_return(() => invoke($8, `load8_u`, [40217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:575
+assert_return(() => invoke($8, `load8_u`, [40416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:576
+assert_return(() => invoke($8, `load8_u`, [40615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:577
+assert_return(() => invoke($8, `load8_u`, [40814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:578
+assert_return(() => invoke($8, `load8_u`, [41013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:579
+assert_return(() => invoke($8, `load8_u`, [41212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:580
+assert_return(() => invoke($8, `load8_u`, [41411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:581
+assert_return(() => invoke($8, `load8_u`, [41610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:582
+assert_return(() => invoke($8, `load8_u`, [41809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:583
+assert_return(() => invoke($8, `load8_u`, [42008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:584
+assert_return(() => invoke($8, `load8_u`, [42207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:585
+assert_return(() => invoke($8, `load8_u`, [42406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:586
+assert_return(() => invoke($8, `load8_u`, [42605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:587
+assert_return(() => invoke($8, `load8_u`, [42804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:588
+assert_return(() => invoke($8, `load8_u`, [43003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:589
+assert_return(() => invoke($8, `load8_u`, [43202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:590
+assert_return(() => invoke($8, `load8_u`, [43401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:591
+assert_return(() => invoke($8, `load8_u`, [43600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:592
+assert_return(() => invoke($8, `load8_u`, [43799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:593
+assert_return(() => invoke($8, `load8_u`, [43998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:594
+assert_return(() => invoke($8, `load8_u`, [44197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:595
+assert_return(() => invoke($8, `load8_u`, [44396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:596
+assert_return(() => invoke($8, `load8_u`, [44595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:597
+assert_return(() => invoke($8, `load8_u`, [44794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:598
+assert_return(() => invoke($8, `load8_u`, [44993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:599
+assert_return(() => invoke($8, `load8_u`, [45192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:600
+assert_return(() => invoke($8, `load8_u`, [45391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:601
+assert_return(() => invoke($8, `load8_u`, [45590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:602
+assert_return(() => invoke($8, `load8_u`, [45789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:603
+assert_return(() => invoke($8, `load8_u`, [45988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:604
+assert_return(() => invoke($8, `load8_u`, [46187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:605
+assert_return(() => invoke($8, `load8_u`, [46386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:606
+assert_return(() => invoke($8, `load8_u`, [46585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:607
+assert_return(() => invoke($8, `load8_u`, [46784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:608
+assert_return(() => invoke($8, `load8_u`, [46983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:609
+assert_return(() => invoke($8, `load8_u`, [47182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:610
+assert_return(() => invoke($8, `load8_u`, [47381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:611
+assert_return(() => invoke($8, `load8_u`, [47580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:612
+assert_return(() => invoke($8, `load8_u`, [47779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:613
+assert_return(() => invoke($8, `load8_u`, [47978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:614
+assert_return(() => invoke($8, `load8_u`, [48177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:615
+assert_return(() => invoke($8, `load8_u`, [48376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:616
+assert_return(() => invoke($8, `load8_u`, [48575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:617
+assert_return(() => invoke($8, `load8_u`, [48774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:618
+assert_return(() => invoke($8, `load8_u`, [48973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:619
+assert_return(() => invoke($8, `load8_u`, [49172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:620
+assert_return(() => invoke($8, `load8_u`, [49371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:621
+assert_return(() => invoke($8, `load8_u`, [49570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:622
+assert_return(() => invoke($8, `load8_u`, [49769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:623
+assert_return(() => invoke($8, `load8_u`, [49968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:624
+assert_return(() => invoke($8, `load8_u`, [50167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:625
+assert_return(() => invoke($8, `load8_u`, [50366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:626
+assert_return(() => invoke($8, `load8_u`, [50565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:627
+assert_return(() => invoke($8, `load8_u`, [50764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:628
+assert_return(() => invoke($8, `load8_u`, [50963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:629
+assert_return(() => invoke($8, `load8_u`, [51162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:630
+assert_return(() => invoke($8, `load8_u`, [51361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:631
+assert_return(() => invoke($8, `load8_u`, [51560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:632
+assert_return(() => invoke($8, `load8_u`, [51759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:633
+assert_return(() => invoke($8, `load8_u`, [51958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:634
+assert_return(() => invoke($8, `load8_u`, [52157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:635
+assert_return(() => invoke($8, `load8_u`, [52356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:636
+assert_return(() => invoke($8, `load8_u`, [52555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:637
+assert_return(() => invoke($8, `load8_u`, [52754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:638
+assert_return(() => invoke($8, `load8_u`, [52953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:639
+assert_return(() => invoke($8, `load8_u`, [53152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:640
+assert_return(() => invoke($8, `load8_u`, [53351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:641
+assert_return(() => invoke($8, `load8_u`, [53550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:642
+assert_return(() => invoke($8, `load8_u`, [53749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:643
+assert_return(() => invoke($8, `load8_u`, [53948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:644
+assert_return(() => invoke($8, `load8_u`, [54147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:645
+assert_return(() => invoke($8, `load8_u`, [54346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:646
+assert_return(() => invoke($8, `load8_u`, [54545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:647
+assert_return(() => invoke($8, `load8_u`, [54744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:648
+assert_return(() => invoke($8, `load8_u`, [54943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:649
+assert_return(() => invoke($8, `load8_u`, [55142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:650
+assert_return(() => invoke($8, `load8_u`, [55341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:651
+assert_return(() => invoke($8, `load8_u`, [55540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:652
+assert_return(() => invoke($8, `load8_u`, [55739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:653
+assert_return(() => invoke($8, `load8_u`, [55938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:654
+assert_return(() => invoke($8, `load8_u`, [56137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:655
+assert_return(() => invoke($8, `load8_u`, [56336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:656
+assert_return(() => invoke($8, `load8_u`, [56535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:657
+assert_return(() => invoke($8, `load8_u`, [56734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:658
+assert_return(() => invoke($8, `load8_u`, [56933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:659
+assert_return(() => invoke($8, `load8_u`, [57132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:660
+assert_return(() => invoke($8, `load8_u`, [57331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:661
+assert_return(() => invoke($8, `load8_u`, [57530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:662
+assert_return(() => invoke($8, `load8_u`, [57729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:663
+assert_return(() => invoke($8, `load8_u`, [57928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:664
+assert_return(() => invoke($8, `load8_u`, [58127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:665
+assert_return(() => invoke($8, `load8_u`, [58326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:666
+assert_return(() => invoke($8, `load8_u`, [58525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:667
+assert_return(() => invoke($8, `load8_u`, [58724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:668
+assert_return(() => invoke($8, `load8_u`, [58923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:669
+assert_return(() => invoke($8, `load8_u`, [59122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:670
+assert_return(() => invoke($8, `load8_u`, [59321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:671
+assert_return(() => invoke($8, `load8_u`, [59520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:672
+assert_return(() => invoke($8, `load8_u`, [59719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:673
+assert_return(() => invoke($8, `load8_u`, [59918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:674
+assert_return(() => invoke($8, `load8_u`, [60117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:675
+assert_return(() => invoke($8, `load8_u`, [60316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:676
+assert_return(() => invoke($8, `load8_u`, [60515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:677
+assert_return(() => invoke($8, `load8_u`, [60714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:678
+assert_return(() => invoke($8, `load8_u`, [60913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:679
+assert_return(() => invoke($8, `load8_u`, [61112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:680
+assert_return(() => invoke($8, `load8_u`, [61311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:681
+assert_return(() => invoke($8, `load8_u`, [61510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:682
+assert_return(() => invoke($8, `load8_u`, [61709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:683
+assert_return(() => invoke($8, `load8_u`, [61908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:684
+assert_return(() => invoke($8, `load8_u`, [62107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:685
+assert_return(() => invoke($8, `load8_u`, [62306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:686
+assert_return(() => invoke($8, `load8_u`, [62505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:687
+assert_return(() => invoke($8, `load8_u`, [62704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:688
+assert_return(() => invoke($8, `load8_u`, [62903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:689
+assert_return(() => invoke($8, `load8_u`, [63102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:690
+assert_return(() => invoke($8, `load8_u`, [63301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:691
+assert_return(() => invoke($8, `load8_u`, [63500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:692
+assert_return(() => invoke($8, `load8_u`, [63699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:693
+assert_return(() => invoke($8, `load8_u`, [63898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:694
+assert_return(() => invoke($8, `load8_u`, [64097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:695
+assert_return(() => invoke($8, `load8_u`, [64296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:696
+assert_return(() => invoke($8, `load8_u`, [64495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:697
+assert_return(() => invoke($8, `load8_u`, [64694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:698
+assert_return(() => invoke($8, `load8_u`, [64893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:699
+assert_return(() => invoke($8, `load8_u`, [65092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:700
+assert_return(() => invoke($8, `load8_u`, [65291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:701
+assert_return(() => invoke($8, `load8_u`, [65490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:703
+let $9 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13\\14")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:711
+assert_trap(() => invoke($9, `run`, [65515, 0, 39]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:714
+assert_return(() => invoke($9, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:715
+assert_return(() => invoke($9, `load8_u`, [1]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:716
+assert_return(() => invoke($9, `load8_u`, [2]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:717
+assert_return(() => invoke($9, `load8_u`, [3]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:718
+assert_return(() => invoke($9, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:719
+assert_return(() => invoke($9, `load8_u`, [5]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:720
+assert_return(() => invoke($9, `load8_u`, [6]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:721
+assert_return(() => invoke($9, `load8_u`, [7]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:722
+assert_return(() => invoke($9, `load8_u`, [8]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:723
+assert_return(() => invoke($9, `load8_u`, [9]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:724
+assert_return(() => invoke($9, `load8_u`, [10]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:725
+assert_return(() => invoke($9, `load8_u`, [11]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:726
+assert_return(() => invoke($9, `load8_u`, [12]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:727
+assert_return(() => invoke($9, `load8_u`, [13]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:728
+assert_return(() => invoke($9, `load8_u`, [14]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:729
+assert_return(() => invoke($9, `load8_u`, [15]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:730
+assert_return(() => invoke($9, `load8_u`, [16]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:731
+assert_return(() => invoke($9, `load8_u`, [17]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:732
+assert_return(() => invoke($9, `load8_u`, [18]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:733
+assert_return(() => invoke($9, `load8_u`, [19]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:734
+assert_return(() => invoke($9, `load8_u`, [20]), [value("i32", 20)]);
+
+// ./test/core/memory_copy.wast:735
+assert_return(() => invoke($9, `load8_u`, [219]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:736
+assert_return(() => invoke($9, `load8_u`, [418]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:737
+assert_return(() => invoke($9, `load8_u`, [617]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:738
+assert_return(() => invoke($9, `load8_u`, [816]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:739
+assert_return(() => invoke($9, `load8_u`, [1015]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:740
+assert_return(() => invoke($9, `load8_u`, [1214]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:741
+assert_return(() => invoke($9, `load8_u`, [1413]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:742
+assert_return(() => invoke($9, `load8_u`, [1612]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:743
+assert_return(() => invoke($9, `load8_u`, [1811]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:744
+assert_return(() => invoke($9, `load8_u`, [2010]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:745
+assert_return(() => invoke($9, `load8_u`, [2209]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:746
+assert_return(() => invoke($9, `load8_u`, [2408]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:747
+assert_return(() => invoke($9, `load8_u`, [2607]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:748
+assert_return(() => invoke($9, `load8_u`, [2806]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:749
+assert_return(() => invoke($9, `load8_u`, [3005]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:750
+assert_return(() => invoke($9, `load8_u`, [3204]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:751
+assert_return(() => invoke($9, `load8_u`, [3403]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:752
+assert_return(() => invoke($9, `load8_u`, [3602]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:753
+assert_return(() => invoke($9, `load8_u`, [3801]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:754
+assert_return(() => invoke($9, `load8_u`, [4000]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:755
+assert_return(() => invoke($9, `load8_u`, [4199]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:756
+assert_return(() => invoke($9, `load8_u`, [4398]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:757
+assert_return(() => invoke($9, `load8_u`, [4597]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:758
+assert_return(() => invoke($9, `load8_u`, [4796]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:759
+assert_return(() => invoke($9, `load8_u`, [4995]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:760
+assert_return(() => invoke($9, `load8_u`, [5194]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:761
+assert_return(() => invoke($9, `load8_u`, [5393]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:762
+assert_return(() => invoke($9, `load8_u`, [5592]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:763
+assert_return(() => invoke($9, `load8_u`, [5791]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:764
+assert_return(() => invoke($9, `load8_u`, [5990]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:765
+assert_return(() => invoke($9, `load8_u`, [6189]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:766
+assert_return(() => invoke($9, `load8_u`, [6388]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:767
+assert_return(() => invoke($9, `load8_u`, [6587]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:768
+assert_return(() => invoke($9, `load8_u`, [6786]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:769
+assert_return(() => invoke($9, `load8_u`, [6985]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:770
+assert_return(() => invoke($9, `load8_u`, [7184]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:771
+assert_return(() => invoke($9, `load8_u`, [7383]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:772
+assert_return(() => invoke($9, `load8_u`, [7582]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:773
+assert_return(() => invoke($9, `load8_u`, [7781]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:774
+assert_return(() => invoke($9, `load8_u`, [7980]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:775
+assert_return(() => invoke($9, `load8_u`, [8179]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:776
+assert_return(() => invoke($9, `load8_u`, [8378]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:777
+assert_return(() => invoke($9, `load8_u`, [8577]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:778
+assert_return(() => invoke($9, `load8_u`, [8776]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:779
+assert_return(() => invoke($9, `load8_u`, [8975]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:780
+assert_return(() => invoke($9, `load8_u`, [9174]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:781
+assert_return(() => invoke($9, `load8_u`, [9373]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:782
+assert_return(() => invoke($9, `load8_u`, [9572]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:783
+assert_return(() => invoke($9, `load8_u`, [9771]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:784
+assert_return(() => invoke($9, `load8_u`, [9970]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:785
+assert_return(() => invoke($9, `load8_u`, [10169]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:786
+assert_return(() => invoke($9, `load8_u`, [10368]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:787
+assert_return(() => invoke($9, `load8_u`, [10567]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:788
+assert_return(() => invoke($9, `load8_u`, [10766]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:789
+assert_return(() => invoke($9, `load8_u`, [10965]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:790
+assert_return(() => invoke($9, `load8_u`, [11164]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:791
+assert_return(() => invoke($9, `load8_u`, [11363]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:792
+assert_return(() => invoke($9, `load8_u`, [11562]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:793
+assert_return(() => invoke($9, `load8_u`, [11761]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:794
+assert_return(() => invoke($9, `load8_u`, [11960]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:795
+assert_return(() => invoke($9, `load8_u`, [12159]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:796
+assert_return(() => invoke($9, `load8_u`, [12358]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:797
+assert_return(() => invoke($9, `load8_u`, [12557]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:798
+assert_return(() => invoke($9, `load8_u`, [12756]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:799
+assert_return(() => invoke($9, `load8_u`, [12955]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:800
+assert_return(() => invoke($9, `load8_u`, [13154]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:801
+assert_return(() => invoke($9, `load8_u`, [13353]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:802
+assert_return(() => invoke($9, `load8_u`, [13552]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:803
+assert_return(() => invoke($9, `load8_u`, [13751]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:804
+assert_return(() => invoke($9, `load8_u`, [13950]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:805
+assert_return(() => invoke($9, `load8_u`, [14149]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:806
+assert_return(() => invoke($9, `load8_u`, [14348]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:807
+assert_return(() => invoke($9, `load8_u`, [14547]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:808
+assert_return(() => invoke($9, `load8_u`, [14746]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:809
+assert_return(() => invoke($9, `load8_u`, [14945]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:810
+assert_return(() => invoke($9, `load8_u`, [15144]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:811
+assert_return(() => invoke($9, `load8_u`, [15343]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:812
+assert_return(() => invoke($9, `load8_u`, [15542]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:813
+assert_return(() => invoke($9, `load8_u`, [15741]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:814
+assert_return(() => invoke($9, `load8_u`, [15940]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:815
+assert_return(() => invoke($9, `load8_u`, [16139]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:816
+assert_return(() => invoke($9, `load8_u`, [16338]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:817
+assert_return(() => invoke($9, `load8_u`, [16537]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:818
+assert_return(() => invoke($9, `load8_u`, [16736]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:819
+assert_return(() => invoke($9, `load8_u`, [16935]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:820
+assert_return(() => invoke($9, `load8_u`, [17134]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:821
+assert_return(() => invoke($9, `load8_u`, [17333]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:822
+assert_return(() => invoke($9, `load8_u`, [17532]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:823
+assert_return(() => invoke($9, `load8_u`, [17731]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:824
+assert_return(() => invoke($9, `load8_u`, [17930]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:825
+assert_return(() => invoke($9, `load8_u`, [18129]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:826
+assert_return(() => invoke($9, `load8_u`, [18328]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:827
+assert_return(() => invoke($9, `load8_u`, [18527]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:828
+assert_return(() => invoke($9, `load8_u`, [18726]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:829
+assert_return(() => invoke($9, `load8_u`, [18925]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:830
+assert_return(() => invoke($9, `load8_u`, [19124]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:831
+assert_return(() => invoke($9, `load8_u`, [19323]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:832
+assert_return(() => invoke($9, `load8_u`, [19522]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:833
+assert_return(() => invoke($9, `load8_u`, [19721]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:834
+assert_return(() => invoke($9, `load8_u`, [19920]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:835
+assert_return(() => invoke($9, `load8_u`, [20119]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:836
+assert_return(() => invoke($9, `load8_u`, [20318]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:837
+assert_return(() => invoke($9, `load8_u`, [20517]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:838
+assert_return(() => invoke($9, `load8_u`, [20716]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:839
+assert_return(() => invoke($9, `load8_u`, [20915]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:840
+assert_return(() => invoke($9, `load8_u`, [21114]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:841
+assert_return(() => invoke($9, `load8_u`, [21313]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:842
+assert_return(() => invoke($9, `load8_u`, [21512]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:843
+assert_return(() => invoke($9, `load8_u`, [21711]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:844
+assert_return(() => invoke($9, `load8_u`, [21910]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:845
+assert_return(() => invoke($9, `load8_u`, [22109]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:846
+assert_return(() => invoke($9, `load8_u`, [22308]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:847
+assert_return(() => invoke($9, `load8_u`, [22507]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:848
+assert_return(() => invoke($9, `load8_u`, [22706]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:849
+assert_return(() => invoke($9, `load8_u`, [22905]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:850
+assert_return(() => invoke($9, `load8_u`, [23104]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:851
+assert_return(() => invoke($9, `load8_u`, [23303]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:852
+assert_return(() => invoke($9, `load8_u`, [23502]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:853
+assert_return(() => invoke($9, `load8_u`, [23701]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:854
+assert_return(() => invoke($9, `load8_u`, [23900]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:855
+assert_return(() => invoke($9, `load8_u`, [24099]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:856
+assert_return(() => invoke($9, `load8_u`, [24298]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:857
+assert_return(() => invoke($9, `load8_u`, [24497]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:858
+assert_return(() => invoke($9, `load8_u`, [24696]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:859
+assert_return(() => invoke($9, `load8_u`, [24895]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:860
+assert_return(() => invoke($9, `load8_u`, [25094]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:861
+assert_return(() => invoke($9, `load8_u`, [25293]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:862
+assert_return(() => invoke($9, `load8_u`, [25492]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:863
+assert_return(() => invoke($9, `load8_u`, [25691]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:864
+assert_return(() => invoke($9, `load8_u`, [25890]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:865
+assert_return(() => invoke($9, `load8_u`, [26089]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:866
+assert_return(() => invoke($9, `load8_u`, [26288]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:867
+assert_return(() => invoke($9, `load8_u`, [26487]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:868
+assert_return(() => invoke($9, `load8_u`, [26686]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:869
+assert_return(() => invoke($9, `load8_u`, [26885]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:870
+assert_return(() => invoke($9, `load8_u`, [27084]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:871
+assert_return(() => invoke($9, `load8_u`, [27283]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:872
+assert_return(() => invoke($9, `load8_u`, [27482]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:873
+assert_return(() => invoke($9, `load8_u`, [27681]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:874
+assert_return(() => invoke($9, `load8_u`, [27880]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:875
+assert_return(() => invoke($9, `load8_u`, [28079]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:876
+assert_return(() => invoke($9, `load8_u`, [28278]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:877
+assert_return(() => invoke($9, `load8_u`, [28477]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:878
+assert_return(() => invoke($9, `load8_u`, [28676]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:879
+assert_return(() => invoke($9, `load8_u`, [28875]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:880
+assert_return(() => invoke($9, `load8_u`, [29074]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:881
+assert_return(() => invoke($9, `load8_u`, [29273]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:882
+assert_return(() => invoke($9, `load8_u`, [29472]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:883
+assert_return(() => invoke($9, `load8_u`, [29671]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:884
+assert_return(() => invoke($9, `load8_u`, [29870]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:885
+assert_return(() => invoke($9, `load8_u`, [30069]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:886
+assert_return(() => invoke($9, `load8_u`, [30268]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:887
+assert_return(() => invoke($9, `load8_u`, [30467]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:888
+assert_return(() => invoke($9, `load8_u`, [30666]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:889
+assert_return(() => invoke($9, `load8_u`, [30865]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:890
+assert_return(() => invoke($9, `load8_u`, [31064]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:891
+assert_return(() => invoke($9, `load8_u`, [31263]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:892
+assert_return(() => invoke($9, `load8_u`, [31462]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:893
+assert_return(() => invoke($9, `load8_u`, [31661]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:894
+assert_return(() => invoke($9, `load8_u`, [31860]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:895
+assert_return(() => invoke($9, `load8_u`, [32059]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:896
+assert_return(() => invoke($9, `load8_u`, [32258]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:897
+assert_return(() => invoke($9, `load8_u`, [32457]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:898
+assert_return(() => invoke($9, `load8_u`, [32656]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:899
+assert_return(() => invoke($9, `load8_u`, [32855]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:900
+assert_return(() => invoke($9, `load8_u`, [33054]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:901
+assert_return(() => invoke($9, `load8_u`, [33253]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:902
+assert_return(() => invoke($9, `load8_u`, [33452]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:903
+assert_return(() => invoke($9, `load8_u`, [33651]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:904
+assert_return(() => invoke($9, `load8_u`, [33850]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:905
+assert_return(() => invoke($9, `load8_u`, [34049]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:906
+assert_return(() => invoke($9, `load8_u`, [34248]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:907
+assert_return(() => invoke($9, `load8_u`, [34447]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:908
+assert_return(() => invoke($9, `load8_u`, [34646]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:909
+assert_return(() => invoke($9, `load8_u`, [34845]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:910
+assert_return(() => invoke($9, `load8_u`, [35044]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:911
+assert_return(() => invoke($9, `load8_u`, [35243]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:912
+assert_return(() => invoke($9, `load8_u`, [35442]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:913
+assert_return(() => invoke($9, `load8_u`, [35641]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:914
+assert_return(() => invoke($9, `load8_u`, [35840]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:915
+assert_return(() => invoke($9, `load8_u`, [36039]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:916
+assert_return(() => invoke($9, `load8_u`, [36238]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:917
+assert_return(() => invoke($9, `load8_u`, [36437]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:918
+assert_return(() => invoke($9, `load8_u`, [36636]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:919
+assert_return(() => invoke($9, `load8_u`, [36835]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:920
+assert_return(() => invoke($9, `load8_u`, [37034]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:921
+assert_return(() => invoke($9, `load8_u`, [37233]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:922
+assert_return(() => invoke($9, `load8_u`, [37432]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:923
+assert_return(() => invoke($9, `load8_u`, [37631]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:924
+assert_return(() => invoke($9, `load8_u`, [37830]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:925
+assert_return(() => invoke($9, `load8_u`, [38029]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:926
+assert_return(() => invoke($9, `load8_u`, [38228]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:927
+assert_return(() => invoke($9, `load8_u`, [38427]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:928
+assert_return(() => invoke($9, `load8_u`, [38626]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:929
+assert_return(() => invoke($9, `load8_u`, [38825]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:930
+assert_return(() => invoke($9, `load8_u`, [39024]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:931
+assert_return(() => invoke($9, `load8_u`, [39223]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:932
+assert_return(() => invoke($9, `load8_u`, [39422]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:933
+assert_return(() => invoke($9, `load8_u`, [39621]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:934
+assert_return(() => invoke($9, `load8_u`, [39820]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:935
+assert_return(() => invoke($9, `load8_u`, [40019]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:936
+assert_return(() => invoke($9, `load8_u`, [40218]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:937
+assert_return(() => invoke($9, `load8_u`, [40417]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:938
+assert_return(() => invoke($9, `load8_u`, [40616]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:939
+assert_return(() => invoke($9, `load8_u`, [40815]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:940
+assert_return(() => invoke($9, `load8_u`, [41014]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:941
+assert_return(() => invoke($9, `load8_u`, [41213]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:942
+assert_return(() => invoke($9, `load8_u`, [41412]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:943
+assert_return(() => invoke($9, `load8_u`, [41611]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:944
+assert_return(() => invoke($9, `load8_u`, [41810]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:945
+assert_return(() => invoke($9, `load8_u`, [42009]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:946
+assert_return(() => invoke($9, `load8_u`, [42208]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:947
+assert_return(() => invoke($9, `load8_u`, [42407]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:948
+assert_return(() => invoke($9, `load8_u`, [42606]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:949
+assert_return(() => invoke($9, `load8_u`, [42805]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:950
+assert_return(() => invoke($9, `load8_u`, [43004]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:951
+assert_return(() => invoke($9, `load8_u`, [43203]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:952
+assert_return(() => invoke($9, `load8_u`, [43402]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:953
+assert_return(() => invoke($9, `load8_u`, [43601]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:954
+assert_return(() => invoke($9, `load8_u`, [43800]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:955
+assert_return(() => invoke($9, `load8_u`, [43999]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:956
+assert_return(() => invoke($9, `load8_u`, [44198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:957
+assert_return(() => invoke($9, `load8_u`, [44397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:958
+assert_return(() => invoke($9, `load8_u`, [44596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:959
+assert_return(() => invoke($9, `load8_u`, [44795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:960
+assert_return(() => invoke($9, `load8_u`, [44994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:961
+assert_return(() => invoke($9, `load8_u`, [45193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:962
+assert_return(() => invoke($9, `load8_u`, [45392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:963
+assert_return(() => invoke($9, `load8_u`, [45591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:964
+assert_return(() => invoke($9, `load8_u`, [45790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:965
+assert_return(() => invoke($9, `load8_u`, [45989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:966
+assert_return(() => invoke($9, `load8_u`, [46188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:967
+assert_return(() => invoke($9, `load8_u`, [46387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:968
+assert_return(() => invoke($9, `load8_u`, [46586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:969
+assert_return(() => invoke($9, `load8_u`, [46785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:970
+assert_return(() => invoke($9, `load8_u`, [46984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:971
+assert_return(() => invoke($9, `load8_u`, [47183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:972
+assert_return(() => invoke($9, `load8_u`, [47382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:973
+assert_return(() => invoke($9, `load8_u`, [47581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:974
+assert_return(() => invoke($9, `load8_u`, [47780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:975
+assert_return(() => invoke($9, `load8_u`, [47979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:976
+assert_return(() => invoke($9, `load8_u`, [48178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:977
+assert_return(() => invoke($9, `load8_u`, [48377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:978
+assert_return(() => invoke($9, `load8_u`, [48576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:979
+assert_return(() => invoke($9, `load8_u`, [48775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:980
+assert_return(() => invoke($9, `load8_u`, [48974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:981
+assert_return(() => invoke($9, `load8_u`, [49173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:982
+assert_return(() => invoke($9, `load8_u`, [49372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:983
+assert_return(() => invoke($9, `load8_u`, [49571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:984
+assert_return(() => invoke($9, `load8_u`, [49770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:985
+assert_return(() => invoke($9, `load8_u`, [49969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:986
+assert_return(() => invoke($9, `load8_u`, [50168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:987
+assert_return(() => invoke($9, `load8_u`, [50367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:988
+assert_return(() => invoke($9, `load8_u`, [50566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:989
+assert_return(() => invoke($9, `load8_u`, [50765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:990
+assert_return(() => invoke($9, `load8_u`, [50964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:991
+assert_return(() => invoke($9, `load8_u`, [51163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:992
+assert_return(() => invoke($9, `load8_u`, [51362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:993
+assert_return(() => invoke($9, `load8_u`, [51561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:994
+assert_return(() => invoke($9, `load8_u`, [51760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:995
+assert_return(() => invoke($9, `load8_u`, [51959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:996
+assert_return(() => invoke($9, `load8_u`, [52158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:997
+assert_return(() => invoke($9, `load8_u`, [52357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:998
+assert_return(() => invoke($9, `load8_u`, [52556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:999
+assert_return(() => invoke($9, `load8_u`, [52755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1000
+assert_return(() => invoke($9, `load8_u`, [52954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1001
+assert_return(() => invoke($9, `load8_u`, [53153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1002
+assert_return(() => invoke($9, `load8_u`, [53352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1003
+assert_return(() => invoke($9, `load8_u`, [53551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1004
+assert_return(() => invoke($9, `load8_u`, [53750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1005
+assert_return(() => invoke($9, `load8_u`, [53949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1006
+assert_return(() => invoke($9, `load8_u`, [54148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1007
+assert_return(() => invoke($9, `load8_u`, [54347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1008
+assert_return(() => invoke($9, `load8_u`, [54546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1009
+assert_return(() => invoke($9, `load8_u`, [54745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1010
+assert_return(() => invoke($9, `load8_u`, [54944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1011
+assert_return(() => invoke($9, `load8_u`, [55143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1012
+assert_return(() => invoke($9, `load8_u`, [55342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1013
+assert_return(() => invoke($9, `load8_u`, [55541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1014
+assert_return(() => invoke($9, `load8_u`, [55740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1015
+assert_return(() => invoke($9, `load8_u`, [55939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1016
+assert_return(() => invoke($9, `load8_u`, [56138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1017
+assert_return(() => invoke($9, `load8_u`, [56337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1018
+assert_return(() => invoke($9, `load8_u`, [56536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1019
+assert_return(() => invoke($9, `load8_u`, [56735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1020
+assert_return(() => invoke($9, `load8_u`, [56934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1021
+assert_return(() => invoke($9, `load8_u`, [57133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1022
+assert_return(() => invoke($9, `load8_u`, [57332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1023
+assert_return(() => invoke($9, `load8_u`, [57531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1024
+assert_return(() => invoke($9, `load8_u`, [57730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1025
+assert_return(() => invoke($9, `load8_u`, [57929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1026
+assert_return(() => invoke($9, `load8_u`, [58128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1027
+assert_return(() => invoke($9, `load8_u`, [58327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1028
+assert_return(() => invoke($9, `load8_u`, [58526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1029
+assert_return(() => invoke($9, `load8_u`, [58725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1030
+assert_return(() => invoke($9, `load8_u`, [58924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1031
+assert_return(() => invoke($9, `load8_u`, [59123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1032
+assert_return(() => invoke($9, `load8_u`, [59322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1033
+assert_return(() => invoke($9, `load8_u`, [59521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1034
+assert_return(() => invoke($9, `load8_u`, [59720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1035
+assert_return(() => invoke($9, `load8_u`, [59919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1036
+assert_return(() => invoke($9, `load8_u`, [60118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1037
+assert_return(() => invoke($9, `load8_u`, [60317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1038
+assert_return(() => invoke($9, `load8_u`, [60516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1039
+assert_return(() => invoke($9, `load8_u`, [60715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1040
+assert_return(() => invoke($9, `load8_u`, [60914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1041
+assert_return(() => invoke($9, `load8_u`, [61113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1042
+assert_return(() => invoke($9, `load8_u`, [61312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1043
+assert_return(() => invoke($9, `load8_u`, [61511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1044
+assert_return(() => invoke($9, `load8_u`, [61710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1045
+assert_return(() => invoke($9, `load8_u`, [61909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1046
+assert_return(() => invoke($9, `load8_u`, [62108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1047
+assert_return(() => invoke($9, `load8_u`, [62307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1048
+assert_return(() => invoke($9, `load8_u`, [62506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1049
+assert_return(() => invoke($9, `load8_u`, [62705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1050
+assert_return(() => invoke($9, `load8_u`, [62904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1051
+assert_return(() => invoke($9, `load8_u`, [63103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1052
+assert_return(() => invoke($9, `load8_u`, [63302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1053
+assert_return(() => invoke($9, `load8_u`, [63501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1054
+assert_return(() => invoke($9, `load8_u`, [63700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1055
+assert_return(() => invoke($9, `load8_u`, [63899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1056
+assert_return(() => invoke($9, `load8_u`, [64098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1057
+assert_return(() => invoke($9, `load8_u`, [64297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1058
+assert_return(() => invoke($9, `load8_u`, [64496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1059
+assert_return(() => invoke($9, `load8_u`, [64695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1060
+assert_return(() => invoke($9, `load8_u`, [64894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1061
+assert_return(() => invoke($9, `load8_u`, [65093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1062
+assert_return(() => invoke($9, `load8_u`, [65292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1063
+assert_return(() => invoke($9, `load8_u`, [65491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1065
+let $10 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:1073
+assert_trap(() => invoke($10, `run`, [0, 65516, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:1076
+assert_return(() => invoke($10, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1077
+assert_return(() => invoke($10, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1078
+assert_return(() => invoke($10, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1079
+assert_return(() => invoke($10, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1080
+assert_return(() => invoke($10, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1081
+assert_return(() => invoke($10, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1082
+assert_return(() => invoke($10, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1083
+assert_return(() => invoke($10, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1084
+assert_return(() => invoke($10, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1085
+assert_return(() => invoke($10, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1086
+assert_return(() => invoke($10, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1087
+assert_return(() => invoke($10, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1088
+assert_return(() => invoke($10, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1089
+assert_return(() => invoke($10, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1090
+assert_return(() => invoke($10, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1091
+assert_return(() => invoke($10, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1092
+assert_return(() => invoke($10, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1093
+assert_return(() => invoke($10, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1094
+assert_return(() => invoke($10, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1095
+assert_return(() => invoke($10, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1096
+assert_return(() => invoke($10, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1097
+assert_return(() => invoke($10, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1098
+assert_return(() => invoke($10, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1099
+assert_return(() => invoke($10, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1100
+assert_return(() => invoke($10, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1101
+assert_return(() => invoke($10, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1102
+assert_return(() => invoke($10, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1103
+assert_return(() => invoke($10, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1104
+assert_return(() => invoke($10, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1105
+assert_return(() => invoke($10, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1106
+assert_return(() => invoke($10, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1107
+assert_return(() => invoke($10, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1108
+assert_return(() => invoke($10, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1109
+assert_return(() => invoke($10, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1110
+assert_return(() => invoke($10, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1111
+assert_return(() => invoke($10, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1112
+assert_return(() => invoke($10, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1113
+assert_return(() => invoke($10, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1114
+assert_return(() => invoke($10, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1115
+assert_return(() => invoke($10, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1116
+assert_return(() => invoke($10, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1117
+assert_return(() => invoke($10, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1118
+assert_return(() => invoke($10, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1119
+assert_return(() => invoke($10, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1120
+assert_return(() => invoke($10, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1121
+assert_return(() => invoke($10, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1122
+assert_return(() => invoke($10, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1123
+assert_return(() => invoke($10, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1124
+assert_return(() => invoke($10, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1125
+assert_return(() => invoke($10, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1126
+assert_return(() => invoke($10, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1127
+assert_return(() => invoke($10, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1128
+assert_return(() => invoke($10, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1129
+assert_return(() => invoke($10, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1130
+assert_return(() => invoke($10, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1131
+assert_return(() => invoke($10, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1132
+assert_return(() => invoke($10, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1133
+assert_return(() => invoke($10, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1134
+assert_return(() => invoke($10, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1135
+assert_return(() => invoke($10, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1136
+assert_return(() => invoke($10, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1137
+assert_return(() => invoke($10, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1138
+assert_return(() => invoke($10, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1139
+assert_return(() => invoke($10, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1140
+assert_return(() => invoke($10, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1141
+assert_return(() => invoke($10, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1142
+assert_return(() => invoke($10, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1143
+assert_return(() => invoke($10, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1144
+assert_return(() => invoke($10, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1145
+assert_return(() => invoke($10, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1146
+assert_return(() => invoke($10, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1147
+assert_return(() => invoke($10, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1148
+assert_return(() => invoke($10, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1149
+assert_return(() => invoke($10, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1150
+assert_return(() => invoke($10, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1151
+assert_return(() => invoke($10, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1152
+assert_return(() => invoke($10, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1153
+assert_return(() => invoke($10, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1154
+assert_return(() => invoke($10, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1155
+assert_return(() => invoke($10, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1156
+assert_return(() => invoke($10, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1157
+assert_return(() => invoke($10, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1158
+assert_return(() => invoke($10, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1159
+assert_return(() => invoke($10, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1160
+assert_return(() => invoke($10, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1161
+assert_return(() => invoke($10, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1162
+assert_return(() => invoke($10, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1163
+assert_return(() => invoke($10, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1164
+assert_return(() => invoke($10, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1165
+assert_return(() => invoke($10, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1166
+assert_return(() => invoke($10, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1167
+assert_return(() => invoke($10, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1168
+assert_return(() => invoke($10, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1169
+assert_return(() => invoke($10, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1170
+assert_return(() => invoke($10, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1171
+assert_return(() => invoke($10, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1172
+assert_return(() => invoke($10, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1173
+assert_return(() => invoke($10, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1174
+assert_return(() => invoke($10, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1175
+assert_return(() => invoke($10, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1176
+assert_return(() => invoke($10, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1177
+assert_return(() => invoke($10, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1178
+assert_return(() => invoke($10, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1179
+assert_return(() => invoke($10, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1180
+assert_return(() => invoke($10, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1181
+assert_return(() => invoke($10, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1182
+assert_return(() => invoke($10, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1183
+assert_return(() => invoke($10, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1184
+assert_return(() => invoke($10, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1185
+assert_return(() => invoke($10, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1186
+assert_return(() => invoke($10, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1187
+assert_return(() => invoke($10, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1188
+assert_return(() => invoke($10, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1189
+assert_return(() => invoke($10, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1190
+assert_return(() => invoke($10, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1191
+assert_return(() => invoke($10, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1192
+assert_return(() => invoke($10, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1193
+assert_return(() => invoke($10, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1194
+assert_return(() => invoke($10, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1195
+assert_return(() => invoke($10, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1196
+assert_return(() => invoke($10, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1197
+assert_return(() => invoke($10, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1198
+assert_return(() => invoke($10, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1199
+assert_return(() => invoke($10, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1200
+assert_return(() => invoke($10, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1201
+assert_return(() => invoke($10, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1202
+assert_return(() => invoke($10, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1203
+assert_return(() => invoke($10, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1204
+assert_return(() => invoke($10, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1205
+assert_return(() => invoke($10, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1206
+assert_return(() => invoke($10, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1207
+assert_return(() => invoke($10, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1208
+assert_return(() => invoke($10, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1209
+assert_return(() => invoke($10, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1210
+assert_return(() => invoke($10, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1211
+assert_return(() => invoke($10, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1212
+assert_return(() => invoke($10, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1213
+assert_return(() => invoke($10, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1214
+assert_return(() => invoke($10, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1215
+assert_return(() => invoke($10, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1216
+assert_return(() => invoke($10, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1217
+assert_return(() => invoke($10, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1218
+assert_return(() => invoke($10, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1219
+assert_return(() => invoke($10, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1220
+assert_return(() => invoke($10, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1221
+assert_return(() => invoke($10, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1222
+assert_return(() => invoke($10, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1223
+assert_return(() => invoke($10, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1224
+assert_return(() => invoke($10, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1225
+assert_return(() => invoke($10, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1226
+assert_return(() => invoke($10, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1227
+assert_return(() => invoke($10, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1228
+assert_return(() => invoke($10, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1229
+assert_return(() => invoke($10, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1230
+assert_return(() => invoke($10, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1231
+assert_return(() => invoke($10, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1232
+assert_return(() => invoke($10, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1233
+assert_return(() => invoke($10, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1234
+assert_return(() => invoke($10, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1235
+assert_return(() => invoke($10, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1236
+assert_return(() => invoke($10, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1237
+assert_return(() => invoke($10, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1238
+assert_return(() => invoke($10, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1239
+assert_return(() => invoke($10, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1240
+assert_return(() => invoke($10, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1241
+assert_return(() => invoke($10, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1242
+assert_return(() => invoke($10, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1243
+assert_return(() => invoke($10, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1244
+assert_return(() => invoke($10, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1245
+assert_return(() => invoke($10, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1246
+assert_return(() => invoke($10, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1247
+assert_return(() => invoke($10, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1248
+assert_return(() => invoke($10, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1249
+assert_return(() => invoke($10, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1250
+assert_return(() => invoke($10, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1251
+assert_return(() => invoke($10, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1252
+assert_return(() => invoke($10, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1253
+assert_return(() => invoke($10, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1254
+assert_return(() => invoke($10, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1255
+assert_return(() => invoke($10, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1256
+assert_return(() => invoke($10, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1257
+assert_return(() => invoke($10, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1258
+assert_return(() => invoke($10, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1259
+assert_return(() => invoke($10, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1260
+assert_return(() => invoke($10, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1261
+assert_return(() => invoke($10, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1262
+assert_return(() => invoke($10, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1263
+assert_return(() => invoke($10, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1264
+assert_return(() => invoke($10, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1265
+assert_return(() => invoke($10, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1266
+assert_return(() => invoke($10, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1267
+assert_return(() => invoke($10, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1268
+assert_return(() => invoke($10, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1269
+assert_return(() => invoke($10, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1270
+assert_return(() => invoke($10, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1271
+assert_return(() => invoke($10, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1272
+assert_return(() => invoke($10, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1273
+assert_return(() => invoke($10, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1274
+assert_return(() => invoke($10, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1275
+assert_return(() => invoke($10, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1276
+assert_return(() => invoke($10, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1277
+assert_return(() => invoke($10, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1278
+assert_return(() => invoke($10, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1279
+assert_return(() => invoke($10, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1280
+assert_return(() => invoke($10, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1281
+assert_return(() => invoke($10, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1282
+assert_return(() => invoke($10, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1283
+assert_return(() => invoke($10, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1284
+assert_return(() => invoke($10, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1285
+assert_return(() => invoke($10, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1286
+assert_return(() => invoke($10, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1287
+assert_return(() => invoke($10, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1288
+assert_return(() => invoke($10, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1289
+assert_return(() => invoke($10, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1290
+assert_return(() => invoke($10, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1291
+assert_return(() => invoke($10, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1292
+assert_return(() => invoke($10, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1293
+assert_return(() => invoke($10, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1294
+assert_return(() => invoke($10, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1295
+assert_return(() => invoke($10, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1296
+assert_return(() => invoke($10, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1297
+assert_return(() => invoke($10, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1298
+assert_return(() => invoke($10, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1299
+assert_return(() => invoke($10, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1300
+assert_return(() => invoke($10, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1301
+assert_return(() => invoke($10, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1302
+assert_return(() => invoke($10, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1303
+assert_return(() => invoke($10, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1304
+assert_return(() => invoke($10, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1305
+assert_return(() => invoke($10, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1306
+assert_return(() => invoke($10, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1307
+assert_return(() => invoke($10, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1308
+assert_return(() => invoke($10, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1309
+assert_return(() => invoke($10, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1310
+assert_return(() => invoke($10, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1311
+assert_return(() => invoke($10, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1312
+assert_return(() => invoke($10, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1313
+assert_return(() => invoke($10, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1314
+assert_return(() => invoke($10, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1315
+assert_return(() => invoke($10, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1316
+assert_return(() => invoke($10, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1317
+assert_return(() => invoke($10, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1318
+assert_return(() => invoke($10, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1319
+assert_return(() => invoke($10, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1320
+assert_return(() => invoke($10, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1321
+assert_return(() => invoke($10, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1322
+assert_return(() => invoke($10, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1323
+assert_return(() => invoke($10, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1324
+assert_return(() => invoke($10, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1325
+assert_return(() => invoke($10, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1326
+assert_return(() => invoke($10, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1327
+assert_return(() => invoke($10, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1328
+assert_return(() => invoke($10, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1329
+assert_return(() => invoke($10, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1330
+assert_return(() => invoke($10, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1331
+assert_return(() => invoke($10, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1332
+assert_return(() => invoke($10, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1333
+assert_return(() => invoke($10, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1334
+assert_return(() => invoke($10, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1335
+assert_return(() => invoke($10, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1336
+assert_return(() => invoke($10, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1337
+assert_return(() => invoke($10, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1338
+assert_return(() => invoke($10, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1339
+assert_return(() => invoke($10, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1340
+assert_return(() => invoke($10, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1341
+assert_return(() => invoke($10, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1342
+assert_return(() => invoke($10, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1343
+assert_return(() => invoke($10, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1344
+assert_return(() => invoke($10, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1345
+assert_return(() => invoke($10, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1346
+assert_return(() => invoke($10, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1347
+assert_return(() => invoke($10, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1348
+assert_return(() => invoke($10, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1349
+assert_return(() => invoke($10, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1350
+assert_return(() => invoke($10, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1351
+assert_return(() => invoke($10, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1352
+assert_return(() => invoke($10, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1353
+assert_return(() => invoke($10, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1354
+assert_return(() => invoke($10, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1355
+assert_return(() => invoke($10, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1356
+assert_return(() => invoke($10, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1357
+assert_return(() => invoke($10, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1358
+assert_return(() => invoke($10, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1359
+assert_return(() => invoke($10, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1360
+assert_return(() => invoke($10, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1361
+assert_return(() => invoke($10, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1362
+assert_return(() => invoke($10, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1363
+assert_return(() => invoke($10, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1364
+assert_return(() => invoke($10, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1365
+assert_return(() => invoke($10, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1366
+assert_return(() => invoke($10, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1367
+assert_return(() => invoke($10, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1368
+assert_return(() => invoke($10, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1369
+assert_return(() => invoke($10, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1370
+assert_return(() => invoke($10, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1371
+assert_return(() => invoke($10, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1372
+assert_return(() => invoke($10, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1373
+assert_return(() => invoke($10, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1374
+assert_return(() => invoke($10, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1375
+assert_return(() => invoke($10, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1376
+assert_return(() => invoke($10, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1377
+assert_return(() => invoke($10, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1378
+assert_return(() => invoke($10, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1379
+assert_return(() => invoke($10, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1380
+assert_return(() => invoke($10, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1381
+assert_return(() => invoke($10, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1382
+assert_return(() => invoke($10, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1383
+assert_return(() => invoke($10, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1384
+assert_return(() => invoke($10, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1385
+assert_return(() => invoke($10, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1386
+assert_return(() => invoke($10, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1387
+assert_return(() => invoke($10, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1388
+assert_return(() => invoke($10, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1389
+assert_return(() => invoke($10, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1390
+assert_return(() => invoke($10, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1391
+assert_return(() => invoke($10, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1392
+assert_return(() => invoke($10, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1393
+assert_return(() => invoke($10, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1394
+assert_return(() => invoke($10, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1395
+assert_return(() => invoke($10, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1396
+assert_return(() => invoke($10, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1397
+assert_return(() => invoke($10, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1398
+assert_return(() => invoke($10, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1399
+assert_return(() => invoke($10, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1400
+assert_return(() => invoke($10, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1401
+assert_return(() => invoke($10, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1402
+assert_return(() => invoke($10, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1403
+assert_return(() => invoke($10, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1404
+assert_return(() => invoke($10, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1405
+assert_return(() => invoke($10, `load8_u`, [65516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1406
+assert_return(() => invoke($10, `load8_u`, [65517]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:1407
+assert_return(() => invoke($10, `load8_u`, [65518]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:1408
+assert_return(() => invoke($10, `load8_u`, [65519]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:1409
+assert_return(() => invoke($10, `load8_u`, [65520]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:1410
+assert_return(() => invoke($10, `load8_u`, [65521]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:1411
+assert_return(() => invoke($10, `load8_u`, [65522]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:1412
+assert_return(() => invoke($10, `load8_u`, [65523]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:1413
+assert_return(() => invoke($10, `load8_u`, [65524]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:1414
+assert_return(() => invoke($10, `load8_u`, [65525]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:1415
+assert_return(() => invoke($10, `load8_u`, [65526]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:1416
+assert_return(() => invoke($10, `load8_u`, [65527]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:1417
+assert_return(() => invoke($10, `load8_u`, [65528]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:1418
+assert_return(() => invoke($10, `load8_u`, [65529]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:1419
+assert_return(() => invoke($10, `load8_u`, [65530]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:1420
+assert_return(() => invoke($10, `load8_u`, [65531]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:1421
+assert_return(() => invoke($10, `load8_u`, [65532]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:1422
+assert_return(() => invoke($10, `load8_u`, [65533]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:1423
+assert_return(() => invoke($10, `load8_u`, [65534]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:1424
+assert_return(() => invoke($10, `load8_u`, [65535]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:1426
+let $11 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65515) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13\\14")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:1434
+assert_trap(() => invoke($11, `run`, [0, 65515, 39]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:1437
+assert_return(() => invoke($11, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1438
+assert_return(() => invoke($11, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1439
+assert_return(() => invoke($11, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1440
+assert_return(() => invoke($11, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1441
+assert_return(() => invoke($11, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1442
+assert_return(() => invoke($11, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1443
+assert_return(() => invoke($11, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1444
+assert_return(() => invoke($11, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1445
+assert_return(() => invoke($11, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1446
+assert_return(() => invoke($11, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1447
+assert_return(() => invoke($11, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1448
+assert_return(() => invoke($11, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1449
+assert_return(() => invoke($11, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1450
+assert_return(() => invoke($11, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1451
+assert_return(() => invoke($11, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1452
+assert_return(() => invoke($11, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1453
+assert_return(() => invoke($11, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1454
+assert_return(() => invoke($11, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1455
+assert_return(() => invoke($11, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1456
+assert_return(() => invoke($11, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1457
+assert_return(() => invoke($11, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1458
+assert_return(() => invoke($11, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1459
+assert_return(() => invoke($11, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1460
+assert_return(() => invoke($11, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1461
+assert_return(() => invoke($11, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1462
+assert_return(() => invoke($11, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1463
+assert_return(() => invoke($11, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1464
+assert_return(() => invoke($11, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1465
+assert_return(() => invoke($11, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1466
+assert_return(() => invoke($11, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1467
+assert_return(() => invoke($11, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1468
+assert_return(() => invoke($11, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1469
+assert_return(() => invoke($11, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1470
+assert_return(() => invoke($11, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1471
+assert_return(() => invoke($11, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1472
+assert_return(() => invoke($11, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1473
+assert_return(() => invoke($11, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1474
+assert_return(() => invoke($11, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1475
+assert_return(() => invoke($11, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1476
+assert_return(() => invoke($11, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1477
+assert_return(() => invoke($11, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1478
+assert_return(() => invoke($11, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1479
+assert_return(() => invoke($11, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1480
+assert_return(() => invoke($11, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1481
+assert_return(() => invoke($11, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1482
+assert_return(() => invoke($11, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1483
+assert_return(() => invoke($11, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1484
+assert_return(() => invoke($11, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1485
+assert_return(() => invoke($11, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1486
+assert_return(() => invoke($11, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1487
+assert_return(() => invoke($11, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1488
+assert_return(() => invoke($11, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1489
+assert_return(() => invoke($11, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1490
+assert_return(() => invoke($11, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1491
+assert_return(() => invoke($11, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1492
+assert_return(() => invoke($11, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1493
+assert_return(() => invoke($11, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1494
+assert_return(() => invoke($11, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1495
+assert_return(() => invoke($11, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1496
+assert_return(() => invoke($11, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1497
+assert_return(() => invoke($11, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1498
+assert_return(() => invoke($11, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1499
+assert_return(() => invoke($11, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1500
+assert_return(() => invoke($11, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1501
+assert_return(() => invoke($11, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1502
+assert_return(() => invoke($11, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1503
+assert_return(() => invoke($11, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1504
+assert_return(() => invoke($11, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1505
+assert_return(() => invoke($11, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1506
+assert_return(() => invoke($11, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1507
+assert_return(() => invoke($11, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1508
+assert_return(() => invoke($11, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1509
+assert_return(() => invoke($11, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1510
+assert_return(() => invoke($11, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1511
+assert_return(() => invoke($11, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1512
+assert_return(() => invoke($11, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1513
+assert_return(() => invoke($11, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1514
+assert_return(() => invoke($11, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1515
+assert_return(() => invoke($11, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1516
+assert_return(() => invoke($11, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1517
+assert_return(() => invoke($11, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1518
+assert_return(() => invoke($11, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1519
+assert_return(() => invoke($11, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1520
+assert_return(() => invoke($11, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1521
+assert_return(() => invoke($11, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1522
+assert_return(() => invoke($11, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1523
+assert_return(() => invoke($11, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1524
+assert_return(() => invoke($11, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1525
+assert_return(() => invoke($11, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1526
+assert_return(() => invoke($11, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1527
+assert_return(() => invoke($11, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1528
+assert_return(() => invoke($11, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1529
+assert_return(() => invoke($11, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1530
+assert_return(() => invoke($11, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1531
+assert_return(() => invoke($11, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1532
+assert_return(() => invoke($11, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1533
+assert_return(() => invoke($11, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1534
+assert_return(() => invoke($11, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1535
+assert_return(() => invoke($11, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1536
+assert_return(() => invoke($11, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1537
+assert_return(() => invoke($11, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1538
+assert_return(() => invoke($11, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1539
+assert_return(() => invoke($11, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1540
+assert_return(() => invoke($11, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1541
+assert_return(() => invoke($11, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1542
+assert_return(() => invoke($11, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1543
+assert_return(() => invoke($11, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1544
+assert_return(() => invoke($11, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1545
+assert_return(() => invoke($11, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1546
+assert_return(() => invoke($11, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1547
+assert_return(() => invoke($11, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1548
+assert_return(() => invoke($11, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1549
+assert_return(() => invoke($11, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1550
+assert_return(() => invoke($11, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1551
+assert_return(() => invoke($11, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1552
+assert_return(() => invoke($11, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1553
+assert_return(() => invoke($11, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1554
+assert_return(() => invoke($11, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1555
+assert_return(() => invoke($11, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1556
+assert_return(() => invoke($11, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1557
+assert_return(() => invoke($11, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1558
+assert_return(() => invoke($11, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1559
+assert_return(() => invoke($11, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1560
+assert_return(() => invoke($11, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1561
+assert_return(() => invoke($11, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1562
+assert_return(() => invoke($11, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1563
+assert_return(() => invoke($11, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1564
+assert_return(() => invoke($11, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1565
+assert_return(() => invoke($11, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1566
+assert_return(() => invoke($11, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1567
+assert_return(() => invoke($11, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1568
+assert_return(() => invoke($11, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1569
+assert_return(() => invoke($11, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1570
+assert_return(() => invoke($11, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1571
+assert_return(() => invoke($11, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1572
+assert_return(() => invoke($11, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1573
+assert_return(() => invoke($11, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1574
+assert_return(() => invoke($11, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1575
+assert_return(() => invoke($11, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1576
+assert_return(() => invoke($11, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1577
+assert_return(() => invoke($11, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1578
+assert_return(() => invoke($11, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1579
+assert_return(() => invoke($11, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1580
+assert_return(() => invoke($11, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1581
+assert_return(() => invoke($11, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1582
+assert_return(() => invoke($11, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1583
+assert_return(() => invoke($11, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1584
+assert_return(() => invoke($11, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1585
+assert_return(() => invoke($11, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1586
+assert_return(() => invoke($11, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1587
+assert_return(() => invoke($11, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1588
+assert_return(() => invoke($11, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1589
+assert_return(() => invoke($11, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1590
+assert_return(() => invoke($11, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1591
+assert_return(() => invoke($11, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1592
+assert_return(() => invoke($11, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1593
+assert_return(() => invoke($11, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1594
+assert_return(() => invoke($11, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1595
+assert_return(() => invoke($11, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1596
+assert_return(() => invoke($11, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1597
+assert_return(() => invoke($11, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1598
+assert_return(() => invoke($11, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1599
+assert_return(() => invoke($11, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1600
+assert_return(() => invoke($11, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1601
+assert_return(() => invoke($11, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1602
+assert_return(() => invoke($11, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1603
+assert_return(() => invoke($11, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1604
+assert_return(() => invoke($11, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1605
+assert_return(() => invoke($11, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1606
+assert_return(() => invoke($11, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1607
+assert_return(() => invoke($11, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1608
+assert_return(() => invoke($11, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1609
+assert_return(() => invoke($11, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1610
+assert_return(() => invoke($11, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1611
+assert_return(() => invoke($11, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1612
+assert_return(() => invoke($11, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1613
+assert_return(() => invoke($11, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1614
+assert_return(() => invoke($11, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1615
+assert_return(() => invoke($11, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1616
+assert_return(() => invoke($11, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1617
+assert_return(() => invoke($11, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1618
+assert_return(() => invoke($11, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1619
+assert_return(() => invoke($11, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1620
+assert_return(() => invoke($11, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1621
+assert_return(() => invoke($11, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1622
+assert_return(() => invoke($11, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1623
+assert_return(() => invoke($11, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1624
+assert_return(() => invoke($11, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1625
+assert_return(() => invoke($11, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1626
+assert_return(() => invoke($11, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1627
+assert_return(() => invoke($11, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1628
+assert_return(() => invoke($11, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1629
+assert_return(() => invoke($11, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1630
+assert_return(() => invoke($11, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1631
+assert_return(() => invoke($11, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1632
+assert_return(() => invoke($11, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1633
+assert_return(() => invoke($11, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1634
+assert_return(() => invoke($11, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1635
+assert_return(() => invoke($11, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1636
+assert_return(() => invoke($11, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1637
+assert_return(() => invoke($11, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1638
+assert_return(() => invoke($11, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1639
+assert_return(() => invoke($11, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1640
+assert_return(() => invoke($11, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1641
+assert_return(() => invoke($11, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1642
+assert_return(() => invoke($11, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1643
+assert_return(() => invoke($11, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1644
+assert_return(() => invoke($11, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1645
+assert_return(() => invoke($11, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1646
+assert_return(() => invoke($11, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1647
+assert_return(() => invoke($11, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1648
+assert_return(() => invoke($11, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1649
+assert_return(() => invoke($11, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1650
+assert_return(() => invoke($11, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1651
+assert_return(() => invoke($11, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1652
+assert_return(() => invoke($11, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1653
+assert_return(() => invoke($11, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1654
+assert_return(() => invoke($11, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1655
+assert_return(() => invoke($11, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1656
+assert_return(() => invoke($11, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1657
+assert_return(() => invoke($11, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1658
+assert_return(() => invoke($11, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1659
+assert_return(() => invoke($11, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1660
+assert_return(() => invoke($11, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1661
+assert_return(() => invoke($11, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1662
+assert_return(() => invoke($11, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1663
+assert_return(() => invoke($11, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1664
+assert_return(() => invoke($11, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1665
+assert_return(() => invoke($11, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1666
+assert_return(() => invoke($11, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1667
+assert_return(() => invoke($11, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1668
+assert_return(() => invoke($11, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1669
+assert_return(() => invoke($11, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1670
+assert_return(() => invoke($11, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1671
+assert_return(() => invoke($11, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1672
+assert_return(() => invoke($11, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1673
+assert_return(() => invoke($11, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1674
+assert_return(() => invoke($11, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1675
+assert_return(() => invoke($11, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1676
+assert_return(() => invoke($11, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1677
+assert_return(() => invoke($11, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1678
+assert_return(() => invoke($11, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1679
+assert_return(() => invoke($11, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1680
+assert_return(() => invoke($11, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1681
+assert_return(() => invoke($11, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1682
+assert_return(() => invoke($11, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1683
+assert_return(() => invoke($11, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1684
+assert_return(() => invoke($11, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1685
+assert_return(() => invoke($11, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1686
+assert_return(() => invoke($11, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1687
+assert_return(() => invoke($11, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1688
+assert_return(() => invoke($11, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1689
+assert_return(() => invoke($11, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1690
+assert_return(() => invoke($11, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1691
+assert_return(() => invoke($11, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1692
+assert_return(() => invoke($11, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1693
+assert_return(() => invoke($11, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1694
+assert_return(() => invoke($11, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1695
+assert_return(() => invoke($11, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1696
+assert_return(() => invoke($11, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1697
+assert_return(() => invoke($11, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1698
+assert_return(() => invoke($11, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1699
+assert_return(() => invoke($11, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1700
+assert_return(() => invoke($11, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1701
+assert_return(() => invoke($11, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1702
+assert_return(() => invoke($11, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1703
+assert_return(() => invoke($11, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1704
+assert_return(() => invoke($11, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1705
+assert_return(() => invoke($11, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1706
+assert_return(() => invoke($11, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1707
+assert_return(() => invoke($11, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1708
+assert_return(() => invoke($11, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1709
+assert_return(() => invoke($11, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1710
+assert_return(() => invoke($11, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1711
+assert_return(() => invoke($11, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1712
+assert_return(() => invoke($11, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1713
+assert_return(() => invoke($11, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1714
+assert_return(() => invoke($11, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1715
+assert_return(() => invoke($11, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1716
+assert_return(() => invoke($11, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1717
+assert_return(() => invoke($11, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1718
+assert_return(() => invoke($11, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1719
+assert_return(() => invoke($11, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1720
+assert_return(() => invoke($11, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1721
+assert_return(() => invoke($11, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1722
+assert_return(() => invoke($11, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1723
+assert_return(() => invoke($11, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1724
+assert_return(() => invoke($11, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1725
+assert_return(() => invoke($11, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1726
+assert_return(() => invoke($11, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1727
+assert_return(() => invoke($11, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1728
+assert_return(() => invoke($11, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1729
+assert_return(() => invoke($11, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1730
+assert_return(() => invoke($11, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1731
+assert_return(() => invoke($11, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1732
+assert_return(() => invoke($11, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1733
+assert_return(() => invoke($11, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1734
+assert_return(() => invoke($11, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1735
+assert_return(() => invoke($11, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1736
+assert_return(() => invoke($11, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1737
+assert_return(() => invoke($11, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1738
+assert_return(() => invoke($11, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1739
+assert_return(() => invoke($11, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1740
+assert_return(() => invoke($11, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1741
+assert_return(() => invoke($11, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1742
+assert_return(() => invoke($11, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1743
+assert_return(() => invoke($11, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1744
+assert_return(() => invoke($11, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1745
+assert_return(() => invoke($11, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1746
+assert_return(() => invoke($11, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1747
+assert_return(() => invoke($11, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1748
+assert_return(() => invoke($11, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1749
+assert_return(() => invoke($11, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1750
+assert_return(() => invoke($11, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1751
+assert_return(() => invoke($11, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1752
+assert_return(() => invoke($11, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1753
+assert_return(() => invoke($11, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1754
+assert_return(() => invoke($11, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1755
+assert_return(() => invoke($11, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1756
+assert_return(() => invoke($11, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1757
+assert_return(() => invoke($11, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1758
+assert_return(() => invoke($11, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1759
+assert_return(() => invoke($11, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1760
+assert_return(() => invoke($11, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1761
+assert_return(() => invoke($11, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1762
+assert_return(() => invoke($11, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1763
+assert_return(() => invoke($11, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1764
+assert_return(() => invoke($11, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1765
+assert_return(() => invoke($11, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1766
+assert_return(() => invoke($11, `load8_u`, [65515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1767
+assert_return(() => invoke($11, `load8_u`, [65516]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:1768
+assert_return(() => invoke($11, `load8_u`, [65517]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:1769
+assert_return(() => invoke($11, `load8_u`, [65518]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:1770
+assert_return(() => invoke($11, `load8_u`, [65519]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:1771
+assert_return(() => invoke($11, `load8_u`, [65520]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:1772
+assert_return(() => invoke($11, `load8_u`, [65521]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:1773
+assert_return(() => invoke($11, `load8_u`, [65522]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:1774
+assert_return(() => invoke($11, `load8_u`, [65523]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:1775
+assert_return(() => invoke($11, `load8_u`, [65524]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:1776
+assert_return(() => invoke($11, `load8_u`, [65525]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:1777
+assert_return(() => invoke($11, `load8_u`, [65526]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:1778
+assert_return(() => invoke($11, `load8_u`, [65527]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:1779
+assert_return(() => invoke($11, `load8_u`, [65528]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:1780
+assert_return(() => invoke($11, `load8_u`, [65529]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:1781
+assert_return(() => invoke($11, `load8_u`, [65530]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:1782
+assert_return(() => invoke($11, `load8_u`, [65531]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:1783
+assert_return(() => invoke($11, `load8_u`, [65532]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:1784
+assert_return(() => invoke($11, `load8_u`, [65533]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:1785
+assert_return(() => invoke($11, `load8_u`, [65534]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:1786
+assert_return(() => invoke($11, `load8_u`, [65535]), [value("i32", 20)]);
+
+// ./test/core/memory_copy.wast:1788
+let $12 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65486) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:1796
+assert_trap(() => invoke($12, `run`, [65516, 65486, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:1799
+assert_return(() => invoke($12, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1800
+assert_return(() => invoke($12, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1801
+assert_return(() => invoke($12, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1802
+assert_return(() => invoke($12, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1803
+assert_return(() => invoke($12, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1804
+assert_return(() => invoke($12, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1805
+assert_return(() => invoke($12, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1806
+assert_return(() => invoke($12, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1807
+assert_return(() => invoke($12, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1808
+assert_return(() => invoke($12, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1809
+assert_return(() => invoke($12, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1810
+assert_return(() => invoke($12, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1811
+assert_return(() => invoke($12, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1812
+assert_return(() => invoke($12, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1813
+assert_return(() => invoke($12, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1814
+assert_return(() => invoke($12, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1815
+assert_return(() => invoke($12, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1816
+assert_return(() => invoke($12, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1817
+assert_return(() => invoke($12, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1818
+assert_return(() => invoke($12, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1819
+assert_return(() => invoke($12, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1820
+assert_return(() => invoke($12, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1821
+assert_return(() => invoke($12, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1822
+assert_return(() => invoke($12, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1823
+assert_return(() => invoke($12, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1824
+assert_return(() => invoke($12, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1825
+assert_return(() => invoke($12, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1826
+assert_return(() => invoke($12, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1827
+assert_return(() => invoke($12, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1828
+assert_return(() => invoke($12, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1829
+assert_return(() => invoke($12, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1830
+assert_return(() => invoke($12, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1831
+assert_return(() => invoke($12, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1832
+assert_return(() => invoke($12, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1833
+assert_return(() => invoke($12, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1834
+assert_return(() => invoke($12, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1835
+assert_return(() => invoke($12, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1836
+assert_return(() => invoke($12, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1837
+assert_return(() => invoke($12, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1838
+assert_return(() => invoke($12, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1839
+assert_return(() => invoke($12, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1840
+assert_return(() => invoke($12, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1841
+assert_return(() => invoke($12, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1842
+assert_return(() => invoke($12, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1843
+assert_return(() => invoke($12, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1844
+assert_return(() => invoke($12, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1845
+assert_return(() => invoke($12, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1846
+assert_return(() => invoke($12, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1847
+assert_return(() => invoke($12, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1848
+assert_return(() => invoke($12, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1849
+assert_return(() => invoke($12, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1850
+assert_return(() => invoke($12, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1851
+assert_return(() => invoke($12, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1852
+assert_return(() => invoke($12, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1853
+assert_return(() => invoke($12, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1854
+assert_return(() => invoke($12, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1855
+assert_return(() => invoke($12, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1856
+assert_return(() => invoke($12, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1857
+assert_return(() => invoke($12, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1858
+assert_return(() => invoke($12, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1859
+assert_return(() => invoke($12, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1860
+assert_return(() => invoke($12, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1861
+assert_return(() => invoke($12, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1862
+assert_return(() => invoke($12, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1863
+assert_return(() => invoke($12, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1864
+assert_return(() => invoke($12, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1865
+assert_return(() => invoke($12, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1866
+assert_return(() => invoke($12, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1867
+assert_return(() => invoke($12, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1868
+assert_return(() => invoke($12, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1869
+assert_return(() => invoke($12, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1870
+assert_return(() => invoke($12, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1871
+assert_return(() => invoke($12, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1872
+assert_return(() => invoke($12, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1873
+assert_return(() => invoke($12, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1874
+assert_return(() => invoke($12, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1875
+assert_return(() => invoke($12, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1876
+assert_return(() => invoke($12, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1877
+assert_return(() => invoke($12, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1878
+assert_return(() => invoke($12, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1879
+assert_return(() => invoke($12, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1880
+assert_return(() => invoke($12, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1881
+assert_return(() => invoke($12, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1882
+assert_return(() => invoke($12, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1883
+assert_return(() => invoke($12, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1884
+assert_return(() => invoke($12, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1885
+assert_return(() => invoke($12, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1886
+assert_return(() => invoke($12, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1887
+assert_return(() => invoke($12, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1888
+assert_return(() => invoke($12, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1889
+assert_return(() => invoke($12, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1890
+assert_return(() => invoke($12, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1891
+assert_return(() => invoke($12, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1892
+assert_return(() => invoke($12, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1893
+assert_return(() => invoke($12, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1894
+assert_return(() => invoke($12, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1895
+assert_return(() => invoke($12, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1896
+assert_return(() => invoke($12, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1897
+assert_return(() => invoke($12, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1898
+assert_return(() => invoke($12, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1899
+assert_return(() => invoke($12, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1900
+assert_return(() => invoke($12, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1901
+assert_return(() => invoke($12, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1902
+assert_return(() => invoke($12, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1903
+assert_return(() => invoke($12, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1904
+assert_return(() => invoke($12, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1905
+assert_return(() => invoke($12, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1906
+assert_return(() => invoke($12, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1907
+assert_return(() => invoke($12, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1908
+assert_return(() => invoke($12, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1909
+assert_return(() => invoke($12, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1910
+assert_return(() => invoke($12, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1911
+assert_return(() => invoke($12, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1912
+assert_return(() => invoke($12, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1913
+assert_return(() => invoke($12, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1914
+assert_return(() => invoke($12, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1915
+assert_return(() => invoke($12, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1916
+assert_return(() => invoke($12, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1917
+assert_return(() => invoke($12, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1918
+assert_return(() => invoke($12, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1919
+assert_return(() => invoke($12, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1920
+assert_return(() => invoke($12, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1921
+assert_return(() => invoke($12, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1922
+assert_return(() => invoke($12, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1923
+assert_return(() => invoke($12, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1924
+assert_return(() => invoke($12, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1925
+assert_return(() => invoke($12, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1926
+assert_return(() => invoke($12, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1927
+assert_return(() => invoke($12, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1928
+assert_return(() => invoke($12, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1929
+assert_return(() => invoke($12, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1930
+assert_return(() => invoke($12, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1931
+assert_return(() => invoke($12, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1932
+assert_return(() => invoke($12, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1933
+assert_return(() => invoke($12, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1934
+assert_return(() => invoke($12, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1935
+assert_return(() => invoke($12, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1936
+assert_return(() => invoke($12, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1937
+assert_return(() => invoke($12, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1938
+assert_return(() => invoke($12, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1939
+assert_return(() => invoke($12, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1940
+assert_return(() => invoke($12, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1941
+assert_return(() => invoke($12, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1942
+assert_return(() => invoke($12, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1943
+assert_return(() => invoke($12, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1944
+assert_return(() => invoke($12, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1945
+assert_return(() => invoke($12, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1946
+assert_return(() => invoke($12, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1947
+assert_return(() => invoke($12, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1948
+assert_return(() => invoke($12, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1949
+assert_return(() => invoke($12, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1950
+assert_return(() => invoke($12, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1951
+assert_return(() => invoke($12, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1952
+assert_return(() => invoke($12, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1953
+assert_return(() => invoke($12, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1954
+assert_return(() => invoke($12, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1955
+assert_return(() => invoke($12, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1956
+assert_return(() => invoke($12, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1957
+assert_return(() => invoke($12, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1958
+assert_return(() => invoke($12, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1959
+assert_return(() => invoke($12, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1960
+assert_return(() => invoke($12, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1961
+assert_return(() => invoke($12, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1962
+assert_return(() => invoke($12, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1963
+assert_return(() => invoke($12, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1964
+assert_return(() => invoke($12, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1965
+assert_return(() => invoke($12, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1966
+assert_return(() => invoke($12, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1967
+assert_return(() => invoke($12, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1968
+assert_return(() => invoke($12, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1969
+assert_return(() => invoke($12, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1970
+assert_return(() => invoke($12, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1971
+assert_return(() => invoke($12, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1972
+assert_return(() => invoke($12, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1973
+assert_return(() => invoke($12, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1974
+assert_return(() => invoke($12, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1975
+assert_return(() => invoke($12, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1976
+assert_return(() => invoke($12, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1977
+assert_return(() => invoke($12, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1978
+assert_return(() => invoke($12, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1979
+assert_return(() => invoke($12, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1980
+assert_return(() => invoke($12, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1981
+assert_return(() => invoke($12, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1982
+assert_return(() => invoke($12, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1983
+assert_return(() => invoke($12, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1984
+assert_return(() => invoke($12, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1985
+assert_return(() => invoke($12, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1986
+assert_return(() => invoke($12, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1987
+assert_return(() => invoke($12, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1988
+assert_return(() => invoke($12, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1989
+assert_return(() => invoke($12, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1990
+assert_return(() => invoke($12, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1991
+assert_return(() => invoke($12, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1992
+assert_return(() => invoke($12, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1993
+assert_return(() => invoke($12, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1994
+assert_return(() => invoke($12, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1995
+assert_return(() => invoke($12, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1996
+assert_return(() => invoke($12, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1997
+assert_return(() => invoke($12, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1998
+assert_return(() => invoke($12, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:1999
+assert_return(() => invoke($12, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2000
+assert_return(() => invoke($12, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2001
+assert_return(() => invoke($12, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2002
+assert_return(() => invoke($12, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2003
+assert_return(() => invoke($12, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2004
+assert_return(() => invoke($12, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2005
+assert_return(() => invoke($12, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2006
+assert_return(() => invoke($12, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2007
+assert_return(() => invoke($12, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2008
+assert_return(() => invoke($12, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2009
+assert_return(() => invoke($12, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2010
+assert_return(() => invoke($12, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2011
+assert_return(() => invoke($12, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2012
+assert_return(() => invoke($12, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2013
+assert_return(() => invoke($12, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2014
+assert_return(() => invoke($12, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2015
+assert_return(() => invoke($12, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2016
+assert_return(() => invoke($12, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2017
+assert_return(() => invoke($12, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2018
+assert_return(() => invoke($12, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2019
+assert_return(() => invoke($12, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2020
+assert_return(() => invoke($12, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2021
+assert_return(() => invoke($12, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2022
+assert_return(() => invoke($12, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2023
+assert_return(() => invoke($12, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2024
+assert_return(() => invoke($12, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2025
+assert_return(() => invoke($12, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2026
+assert_return(() => invoke($12, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2027
+assert_return(() => invoke($12, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2028
+assert_return(() => invoke($12, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2029
+assert_return(() => invoke($12, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2030
+assert_return(() => invoke($12, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2031
+assert_return(() => invoke($12, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2032
+assert_return(() => invoke($12, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2033
+assert_return(() => invoke($12, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2034
+assert_return(() => invoke($12, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2035
+assert_return(() => invoke($12, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2036
+assert_return(() => invoke($12, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2037
+assert_return(() => invoke($12, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2038
+assert_return(() => invoke($12, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2039
+assert_return(() => invoke($12, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2040
+assert_return(() => invoke($12, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2041
+assert_return(() => invoke($12, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2042
+assert_return(() => invoke($12, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2043
+assert_return(() => invoke($12, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2044
+assert_return(() => invoke($12, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2045
+assert_return(() => invoke($12, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2046
+assert_return(() => invoke($12, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2047
+assert_return(() => invoke($12, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2048
+assert_return(() => invoke($12, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2049
+assert_return(() => invoke($12, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2050
+assert_return(() => invoke($12, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2051
+assert_return(() => invoke($12, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2052
+assert_return(() => invoke($12, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2053
+assert_return(() => invoke($12, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2054
+assert_return(() => invoke($12, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2055
+assert_return(() => invoke($12, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2056
+assert_return(() => invoke($12, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2057
+assert_return(() => invoke($12, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2058
+assert_return(() => invoke($12, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2059
+assert_return(() => invoke($12, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2060
+assert_return(() => invoke($12, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2061
+assert_return(() => invoke($12, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2062
+assert_return(() => invoke($12, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2063
+assert_return(() => invoke($12, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2064
+assert_return(() => invoke($12, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2065
+assert_return(() => invoke($12, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2066
+assert_return(() => invoke($12, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2067
+assert_return(() => invoke($12, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2068
+assert_return(() => invoke($12, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2069
+assert_return(() => invoke($12, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2070
+assert_return(() => invoke($12, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2071
+assert_return(() => invoke($12, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2072
+assert_return(() => invoke($12, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2073
+assert_return(() => invoke($12, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2074
+assert_return(() => invoke($12, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2075
+assert_return(() => invoke($12, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2076
+assert_return(() => invoke($12, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2077
+assert_return(() => invoke($12, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2078
+assert_return(() => invoke($12, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2079
+assert_return(() => invoke($12, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2080
+assert_return(() => invoke($12, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2081
+assert_return(() => invoke($12, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2082
+assert_return(() => invoke($12, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2083
+assert_return(() => invoke($12, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2084
+assert_return(() => invoke($12, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2085
+assert_return(() => invoke($12, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2086
+assert_return(() => invoke($12, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2087
+assert_return(() => invoke($12, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2088
+assert_return(() => invoke($12, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2089
+assert_return(() => invoke($12, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2090
+assert_return(() => invoke($12, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2091
+assert_return(() => invoke($12, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2092
+assert_return(() => invoke($12, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2093
+assert_return(() => invoke($12, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2094
+assert_return(() => invoke($12, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2095
+assert_return(() => invoke($12, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2096
+assert_return(() => invoke($12, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2097
+assert_return(() => invoke($12, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2098
+assert_return(() => invoke($12, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2099
+assert_return(() => invoke($12, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2100
+assert_return(() => invoke($12, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2101
+assert_return(() => invoke($12, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2102
+assert_return(() => invoke($12, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2103
+assert_return(() => invoke($12, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2104
+assert_return(() => invoke($12, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2105
+assert_return(() => invoke($12, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2106
+assert_return(() => invoke($12, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2107
+assert_return(() => invoke($12, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2108
+assert_return(() => invoke($12, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2109
+assert_return(() => invoke($12, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2110
+assert_return(() => invoke($12, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2111
+assert_return(() => invoke($12, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2112
+assert_return(() => invoke($12, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2113
+assert_return(() => invoke($12, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2114
+assert_return(() => invoke($12, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2115
+assert_return(() => invoke($12, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2116
+assert_return(() => invoke($12, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2117
+assert_return(() => invoke($12, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2118
+assert_return(() => invoke($12, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2119
+assert_return(() => invoke($12, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2120
+assert_return(() => invoke($12, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2121
+assert_return(() => invoke($12, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2122
+assert_return(() => invoke($12, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2123
+assert_return(() => invoke($12, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2124
+assert_return(() => invoke($12, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2125
+assert_return(() => invoke($12, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2126
+assert_return(() => invoke($12, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2127
+assert_return(() => invoke($12, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2128
+assert_return(() => invoke($12, `load8_u`, [65486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2129
+assert_return(() => invoke($12, `load8_u`, [65487]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:2130
+assert_return(() => invoke($12, `load8_u`, [65488]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:2131
+assert_return(() => invoke($12, `load8_u`, [65489]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:2132
+assert_return(() => invoke($12, `load8_u`, [65490]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:2133
+assert_return(() => invoke($12, `load8_u`, [65491]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:2134
+assert_return(() => invoke($12, `load8_u`, [65492]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:2135
+assert_return(() => invoke($12, `load8_u`, [65493]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:2136
+assert_return(() => invoke($12, `load8_u`, [65494]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:2137
+assert_return(() => invoke($12, `load8_u`, [65495]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:2138
+assert_return(() => invoke($12, `load8_u`, [65496]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:2139
+assert_return(() => invoke($12, `load8_u`, [65497]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:2140
+assert_return(() => invoke($12, `load8_u`, [65498]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:2141
+assert_return(() => invoke($12, `load8_u`, [65499]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:2142
+assert_return(() => invoke($12, `load8_u`, [65500]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:2143
+assert_return(() => invoke($12, `load8_u`, [65501]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:2144
+assert_return(() => invoke($12, `load8_u`, [65502]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:2145
+assert_return(() => invoke($12, `load8_u`, [65503]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:2146
+assert_return(() => invoke($12, `load8_u`, [65504]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:2147
+assert_return(() => invoke($12, `load8_u`, [65505]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:2149
+let $13 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:2157
+assert_trap(() => invoke($13, `run`, [65486, 65516, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:2160
+assert_return(() => invoke($13, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2161
+assert_return(() => invoke($13, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2162
+assert_return(() => invoke($13, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2163
+assert_return(() => invoke($13, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2164
+assert_return(() => invoke($13, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2165
+assert_return(() => invoke($13, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2166
+assert_return(() => invoke($13, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2167
+assert_return(() => invoke($13, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2168
+assert_return(() => invoke($13, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2169
+assert_return(() => invoke($13, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2170
+assert_return(() => invoke($13, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2171
+assert_return(() => invoke($13, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2172
+assert_return(() => invoke($13, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2173
+assert_return(() => invoke($13, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2174
+assert_return(() => invoke($13, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2175
+assert_return(() => invoke($13, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2176
+assert_return(() => invoke($13, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2177
+assert_return(() => invoke($13, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2178
+assert_return(() => invoke($13, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2179
+assert_return(() => invoke($13, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2180
+assert_return(() => invoke($13, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2181
+assert_return(() => invoke($13, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2182
+assert_return(() => invoke($13, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2183
+assert_return(() => invoke($13, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2184
+assert_return(() => invoke($13, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2185
+assert_return(() => invoke($13, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2186
+assert_return(() => invoke($13, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2187
+assert_return(() => invoke($13, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2188
+assert_return(() => invoke($13, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2189
+assert_return(() => invoke($13, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2190
+assert_return(() => invoke($13, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2191
+assert_return(() => invoke($13, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2192
+assert_return(() => invoke($13, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2193
+assert_return(() => invoke($13, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2194
+assert_return(() => invoke($13, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2195
+assert_return(() => invoke($13, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2196
+assert_return(() => invoke($13, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2197
+assert_return(() => invoke($13, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2198
+assert_return(() => invoke($13, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2199
+assert_return(() => invoke($13, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2200
+assert_return(() => invoke($13, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2201
+assert_return(() => invoke($13, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2202
+assert_return(() => invoke($13, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2203
+assert_return(() => invoke($13, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2204
+assert_return(() => invoke($13, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2205
+assert_return(() => invoke($13, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2206
+assert_return(() => invoke($13, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2207
+assert_return(() => invoke($13, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2208
+assert_return(() => invoke($13, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2209
+assert_return(() => invoke($13, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2210
+assert_return(() => invoke($13, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2211
+assert_return(() => invoke($13, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2212
+assert_return(() => invoke($13, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2213
+assert_return(() => invoke($13, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2214
+assert_return(() => invoke($13, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2215
+assert_return(() => invoke($13, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2216
+assert_return(() => invoke($13, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2217
+assert_return(() => invoke($13, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2218
+assert_return(() => invoke($13, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2219
+assert_return(() => invoke($13, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2220
+assert_return(() => invoke($13, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2221
+assert_return(() => invoke($13, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2222
+assert_return(() => invoke($13, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2223
+assert_return(() => invoke($13, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2224
+assert_return(() => invoke($13, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2225
+assert_return(() => invoke($13, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2226
+assert_return(() => invoke($13, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2227
+assert_return(() => invoke($13, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2228
+assert_return(() => invoke($13, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2229
+assert_return(() => invoke($13, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2230
+assert_return(() => invoke($13, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2231
+assert_return(() => invoke($13, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2232
+assert_return(() => invoke($13, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2233
+assert_return(() => invoke($13, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2234
+assert_return(() => invoke($13, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2235
+assert_return(() => invoke($13, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2236
+assert_return(() => invoke($13, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2237
+assert_return(() => invoke($13, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2238
+assert_return(() => invoke($13, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2239
+assert_return(() => invoke($13, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2240
+assert_return(() => invoke($13, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2241
+assert_return(() => invoke($13, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2242
+assert_return(() => invoke($13, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2243
+assert_return(() => invoke($13, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2244
+assert_return(() => invoke($13, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2245
+assert_return(() => invoke($13, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2246
+assert_return(() => invoke($13, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2247
+assert_return(() => invoke($13, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2248
+assert_return(() => invoke($13, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2249
+assert_return(() => invoke($13, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2250
+assert_return(() => invoke($13, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2251
+assert_return(() => invoke($13, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2252
+assert_return(() => invoke($13, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2253
+assert_return(() => invoke($13, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2254
+assert_return(() => invoke($13, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2255
+assert_return(() => invoke($13, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2256
+assert_return(() => invoke($13, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2257
+assert_return(() => invoke($13, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2258
+assert_return(() => invoke($13, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2259
+assert_return(() => invoke($13, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2260
+assert_return(() => invoke($13, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2261
+assert_return(() => invoke($13, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2262
+assert_return(() => invoke($13, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2263
+assert_return(() => invoke($13, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2264
+assert_return(() => invoke($13, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2265
+assert_return(() => invoke($13, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2266
+assert_return(() => invoke($13, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2267
+assert_return(() => invoke($13, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2268
+assert_return(() => invoke($13, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2269
+assert_return(() => invoke($13, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2270
+assert_return(() => invoke($13, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2271
+assert_return(() => invoke($13, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2272
+assert_return(() => invoke($13, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2273
+assert_return(() => invoke($13, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2274
+assert_return(() => invoke($13, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2275
+assert_return(() => invoke($13, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2276
+assert_return(() => invoke($13, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2277
+assert_return(() => invoke($13, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2278
+assert_return(() => invoke($13, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2279
+assert_return(() => invoke($13, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2280
+assert_return(() => invoke($13, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2281
+assert_return(() => invoke($13, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2282
+assert_return(() => invoke($13, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2283
+assert_return(() => invoke($13, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2284
+assert_return(() => invoke($13, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2285
+assert_return(() => invoke($13, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2286
+assert_return(() => invoke($13, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2287
+assert_return(() => invoke($13, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2288
+assert_return(() => invoke($13, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2289
+assert_return(() => invoke($13, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2290
+assert_return(() => invoke($13, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2291
+assert_return(() => invoke($13, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2292
+assert_return(() => invoke($13, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2293
+assert_return(() => invoke($13, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2294
+assert_return(() => invoke($13, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2295
+assert_return(() => invoke($13, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2296
+assert_return(() => invoke($13, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2297
+assert_return(() => invoke($13, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2298
+assert_return(() => invoke($13, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2299
+assert_return(() => invoke($13, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2300
+assert_return(() => invoke($13, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2301
+assert_return(() => invoke($13, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2302
+assert_return(() => invoke($13, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2303
+assert_return(() => invoke($13, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2304
+assert_return(() => invoke($13, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2305
+assert_return(() => invoke($13, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2306
+assert_return(() => invoke($13, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2307
+assert_return(() => invoke($13, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2308
+assert_return(() => invoke($13, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2309
+assert_return(() => invoke($13, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2310
+assert_return(() => invoke($13, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2311
+assert_return(() => invoke($13, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2312
+assert_return(() => invoke($13, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2313
+assert_return(() => invoke($13, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2314
+assert_return(() => invoke($13, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2315
+assert_return(() => invoke($13, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2316
+assert_return(() => invoke($13, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2317
+assert_return(() => invoke($13, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2318
+assert_return(() => invoke($13, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2319
+assert_return(() => invoke($13, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2320
+assert_return(() => invoke($13, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2321
+assert_return(() => invoke($13, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2322
+assert_return(() => invoke($13, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2323
+assert_return(() => invoke($13, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2324
+assert_return(() => invoke($13, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2325
+assert_return(() => invoke($13, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2326
+assert_return(() => invoke($13, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2327
+assert_return(() => invoke($13, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2328
+assert_return(() => invoke($13, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2329
+assert_return(() => invoke($13, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2330
+assert_return(() => invoke($13, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2331
+assert_return(() => invoke($13, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2332
+assert_return(() => invoke($13, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2333
+assert_return(() => invoke($13, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2334
+assert_return(() => invoke($13, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2335
+assert_return(() => invoke($13, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2336
+assert_return(() => invoke($13, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2337
+assert_return(() => invoke($13, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2338
+assert_return(() => invoke($13, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2339
+assert_return(() => invoke($13, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2340
+assert_return(() => invoke($13, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2341
+assert_return(() => invoke($13, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2342
+assert_return(() => invoke($13, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2343
+assert_return(() => invoke($13, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2344
+assert_return(() => invoke($13, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2345
+assert_return(() => invoke($13, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2346
+assert_return(() => invoke($13, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2347
+assert_return(() => invoke($13, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2348
+assert_return(() => invoke($13, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2349
+assert_return(() => invoke($13, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2350
+assert_return(() => invoke($13, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2351
+assert_return(() => invoke($13, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2352
+assert_return(() => invoke($13, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2353
+assert_return(() => invoke($13, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2354
+assert_return(() => invoke($13, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2355
+assert_return(() => invoke($13, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2356
+assert_return(() => invoke($13, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2357
+assert_return(() => invoke($13, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2358
+assert_return(() => invoke($13, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2359
+assert_return(() => invoke($13, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2360
+assert_return(() => invoke($13, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2361
+assert_return(() => invoke($13, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2362
+assert_return(() => invoke($13, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2363
+assert_return(() => invoke($13, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2364
+assert_return(() => invoke($13, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2365
+assert_return(() => invoke($13, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2366
+assert_return(() => invoke($13, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2367
+assert_return(() => invoke($13, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2368
+assert_return(() => invoke($13, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2369
+assert_return(() => invoke($13, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2370
+assert_return(() => invoke($13, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2371
+assert_return(() => invoke($13, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2372
+assert_return(() => invoke($13, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2373
+assert_return(() => invoke($13, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2374
+assert_return(() => invoke($13, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2375
+assert_return(() => invoke($13, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2376
+assert_return(() => invoke($13, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2377
+assert_return(() => invoke($13, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2378
+assert_return(() => invoke($13, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2379
+assert_return(() => invoke($13, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2380
+assert_return(() => invoke($13, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2381
+assert_return(() => invoke($13, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2382
+assert_return(() => invoke($13, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2383
+assert_return(() => invoke($13, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2384
+assert_return(() => invoke($13, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2385
+assert_return(() => invoke($13, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2386
+assert_return(() => invoke($13, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2387
+assert_return(() => invoke($13, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2388
+assert_return(() => invoke($13, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2389
+assert_return(() => invoke($13, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2390
+assert_return(() => invoke($13, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2391
+assert_return(() => invoke($13, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2392
+assert_return(() => invoke($13, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2393
+assert_return(() => invoke($13, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2394
+assert_return(() => invoke($13, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2395
+assert_return(() => invoke($13, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2396
+assert_return(() => invoke($13, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2397
+assert_return(() => invoke($13, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2398
+assert_return(() => invoke($13, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2399
+assert_return(() => invoke($13, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2400
+assert_return(() => invoke($13, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2401
+assert_return(() => invoke($13, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2402
+assert_return(() => invoke($13, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2403
+assert_return(() => invoke($13, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2404
+assert_return(() => invoke($13, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2405
+assert_return(() => invoke($13, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2406
+assert_return(() => invoke($13, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2407
+assert_return(() => invoke($13, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2408
+assert_return(() => invoke($13, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2409
+assert_return(() => invoke($13, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2410
+assert_return(() => invoke($13, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2411
+assert_return(() => invoke($13, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2412
+assert_return(() => invoke($13, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2413
+assert_return(() => invoke($13, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2414
+assert_return(() => invoke($13, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2415
+assert_return(() => invoke($13, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2416
+assert_return(() => invoke($13, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2417
+assert_return(() => invoke($13, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2418
+assert_return(() => invoke($13, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2419
+assert_return(() => invoke($13, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2420
+assert_return(() => invoke($13, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2421
+assert_return(() => invoke($13, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2422
+assert_return(() => invoke($13, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2423
+assert_return(() => invoke($13, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2424
+assert_return(() => invoke($13, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2425
+assert_return(() => invoke($13, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2426
+assert_return(() => invoke($13, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2427
+assert_return(() => invoke($13, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2428
+assert_return(() => invoke($13, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2429
+assert_return(() => invoke($13, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2430
+assert_return(() => invoke($13, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2431
+assert_return(() => invoke($13, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2432
+assert_return(() => invoke($13, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2433
+assert_return(() => invoke($13, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2434
+assert_return(() => invoke($13, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2435
+assert_return(() => invoke($13, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2436
+assert_return(() => invoke($13, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2437
+assert_return(() => invoke($13, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2438
+assert_return(() => invoke($13, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2439
+assert_return(() => invoke($13, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2440
+assert_return(() => invoke($13, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2441
+assert_return(() => invoke($13, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2442
+assert_return(() => invoke($13, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2443
+assert_return(() => invoke($13, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2444
+assert_return(() => invoke($13, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2445
+assert_return(() => invoke($13, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2446
+assert_return(() => invoke($13, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2447
+assert_return(() => invoke($13, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2448
+assert_return(() => invoke($13, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2449
+assert_return(() => invoke($13, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2450
+assert_return(() => invoke($13, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2451
+assert_return(() => invoke($13, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2452
+assert_return(() => invoke($13, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2453
+assert_return(() => invoke($13, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2454
+assert_return(() => invoke($13, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2455
+assert_return(() => invoke($13, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2456
+assert_return(() => invoke($13, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2457
+assert_return(() => invoke($13, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2458
+assert_return(() => invoke($13, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2459
+assert_return(() => invoke($13, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2460
+assert_return(() => invoke($13, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2461
+assert_return(() => invoke($13, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2462
+assert_return(() => invoke($13, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2463
+assert_return(() => invoke($13, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2464
+assert_return(() => invoke($13, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2465
+assert_return(() => invoke($13, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2466
+assert_return(() => invoke($13, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2467
+assert_return(() => invoke($13, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2468
+assert_return(() => invoke($13, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2469
+assert_return(() => invoke($13, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2470
+assert_return(() => invoke($13, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2471
+assert_return(() => invoke($13, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2472
+assert_return(() => invoke($13, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2473
+assert_return(() => invoke($13, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2474
+assert_return(() => invoke($13, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2475
+assert_return(() => invoke($13, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2476
+assert_return(() => invoke($13, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2477
+assert_return(() => invoke($13, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2478
+assert_return(() => invoke($13, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2479
+assert_return(() => invoke($13, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2480
+assert_return(() => invoke($13, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2481
+assert_return(() => invoke($13, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2482
+assert_return(() => invoke($13, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2483
+assert_return(() => invoke($13, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2484
+assert_return(() => invoke($13, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2485
+assert_return(() => invoke($13, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2486
+assert_return(() => invoke($13, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2487
+assert_return(() => invoke($13, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2488
+assert_return(() => invoke($13, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2489
+assert_return(() => invoke($13, `load8_u`, [65516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2490
+assert_return(() => invoke($13, `load8_u`, [65517]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:2491
+assert_return(() => invoke($13, `load8_u`, [65518]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:2492
+assert_return(() => invoke($13, `load8_u`, [65519]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:2493
+assert_return(() => invoke($13, `load8_u`, [65520]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:2494
+assert_return(() => invoke($13, `load8_u`, [65521]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:2495
+assert_return(() => invoke($13, `load8_u`, [65522]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:2496
+assert_return(() => invoke($13, `load8_u`, [65523]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:2497
+assert_return(() => invoke($13, `load8_u`, [65524]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:2498
+assert_return(() => invoke($13, `load8_u`, [65525]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:2499
+assert_return(() => invoke($13, `load8_u`, [65526]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:2500
+assert_return(() => invoke($13, `load8_u`, [65527]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:2501
+assert_return(() => invoke($13, `load8_u`, [65528]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:2502
+assert_return(() => invoke($13, `load8_u`, [65529]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:2503
+assert_return(() => invoke($13, `load8_u`, [65530]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:2504
+assert_return(() => invoke($13, `load8_u`, [65531]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:2505
+assert_return(() => invoke($13, `load8_u`, [65532]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:2506
+assert_return(() => invoke($13, `load8_u`, [65533]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:2507
+assert_return(() => invoke($13, `load8_u`, [65534]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:2508
+assert_return(() => invoke($13, `load8_u`, [65535]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:2510
+let $14 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65506) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:2518
+assert_trap(() => invoke($14, `run`, [65516, 65506, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:2521
+assert_return(() => invoke($14, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2522
+assert_return(() => invoke($14, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2523
+assert_return(() => invoke($14, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2524
+assert_return(() => invoke($14, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2525
+assert_return(() => invoke($14, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2526
+assert_return(() => invoke($14, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2527
+assert_return(() => invoke($14, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2528
+assert_return(() => invoke($14, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2529
+assert_return(() => invoke($14, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2530
+assert_return(() => invoke($14, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2531
+assert_return(() => invoke($14, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2532
+assert_return(() => invoke($14, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2533
+assert_return(() => invoke($14, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2534
+assert_return(() => invoke($14, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2535
+assert_return(() => invoke($14, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2536
+assert_return(() => invoke($14, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2537
+assert_return(() => invoke($14, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2538
+assert_return(() => invoke($14, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2539
+assert_return(() => invoke($14, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2540
+assert_return(() => invoke($14, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2541
+assert_return(() => invoke($14, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2542
+assert_return(() => invoke($14, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2543
+assert_return(() => invoke($14, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2544
+assert_return(() => invoke($14, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2545
+assert_return(() => invoke($14, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2546
+assert_return(() => invoke($14, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2547
+assert_return(() => invoke($14, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2548
+assert_return(() => invoke($14, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2549
+assert_return(() => invoke($14, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2550
+assert_return(() => invoke($14, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2551
+assert_return(() => invoke($14, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2552
+assert_return(() => invoke($14, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2553
+assert_return(() => invoke($14, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2554
+assert_return(() => invoke($14, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2555
+assert_return(() => invoke($14, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2556
+assert_return(() => invoke($14, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2557
+assert_return(() => invoke($14, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2558
+assert_return(() => invoke($14, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2559
+assert_return(() => invoke($14, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2560
+assert_return(() => invoke($14, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2561
+assert_return(() => invoke($14, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2562
+assert_return(() => invoke($14, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2563
+assert_return(() => invoke($14, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2564
+assert_return(() => invoke($14, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2565
+assert_return(() => invoke($14, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2566
+assert_return(() => invoke($14, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2567
+assert_return(() => invoke($14, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2568
+assert_return(() => invoke($14, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2569
+assert_return(() => invoke($14, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2570
+assert_return(() => invoke($14, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2571
+assert_return(() => invoke($14, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2572
+assert_return(() => invoke($14, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2573
+assert_return(() => invoke($14, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2574
+assert_return(() => invoke($14, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2575
+assert_return(() => invoke($14, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2576
+assert_return(() => invoke($14, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2577
+assert_return(() => invoke($14, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2578
+assert_return(() => invoke($14, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2579
+assert_return(() => invoke($14, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2580
+assert_return(() => invoke($14, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2581
+assert_return(() => invoke($14, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2582
+assert_return(() => invoke($14, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2583
+assert_return(() => invoke($14, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2584
+assert_return(() => invoke($14, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2585
+assert_return(() => invoke($14, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2586
+assert_return(() => invoke($14, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2587
+assert_return(() => invoke($14, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2588
+assert_return(() => invoke($14, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2589
+assert_return(() => invoke($14, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2590
+assert_return(() => invoke($14, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2591
+assert_return(() => invoke($14, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2592
+assert_return(() => invoke($14, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2593
+assert_return(() => invoke($14, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2594
+assert_return(() => invoke($14, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2595
+assert_return(() => invoke($14, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2596
+assert_return(() => invoke($14, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2597
+assert_return(() => invoke($14, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2598
+assert_return(() => invoke($14, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2599
+assert_return(() => invoke($14, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2600
+assert_return(() => invoke($14, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2601
+assert_return(() => invoke($14, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2602
+assert_return(() => invoke($14, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2603
+assert_return(() => invoke($14, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2604
+assert_return(() => invoke($14, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2605
+assert_return(() => invoke($14, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2606
+assert_return(() => invoke($14, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2607
+assert_return(() => invoke($14, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2608
+assert_return(() => invoke($14, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2609
+assert_return(() => invoke($14, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2610
+assert_return(() => invoke($14, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2611
+assert_return(() => invoke($14, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2612
+assert_return(() => invoke($14, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2613
+assert_return(() => invoke($14, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2614
+assert_return(() => invoke($14, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2615
+assert_return(() => invoke($14, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2616
+assert_return(() => invoke($14, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2617
+assert_return(() => invoke($14, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2618
+assert_return(() => invoke($14, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2619
+assert_return(() => invoke($14, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2620
+assert_return(() => invoke($14, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2621
+assert_return(() => invoke($14, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2622
+assert_return(() => invoke($14, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2623
+assert_return(() => invoke($14, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2624
+assert_return(() => invoke($14, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2625
+assert_return(() => invoke($14, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2626
+assert_return(() => invoke($14, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2627
+assert_return(() => invoke($14, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2628
+assert_return(() => invoke($14, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2629
+assert_return(() => invoke($14, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2630
+assert_return(() => invoke($14, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2631
+assert_return(() => invoke($14, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2632
+assert_return(() => invoke($14, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2633
+assert_return(() => invoke($14, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2634
+assert_return(() => invoke($14, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2635
+assert_return(() => invoke($14, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2636
+assert_return(() => invoke($14, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2637
+assert_return(() => invoke($14, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2638
+assert_return(() => invoke($14, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2639
+assert_return(() => invoke($14, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2640
+assert_return(() => invoke($14, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2641
+assert_return(() => invoke($14, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2642
+assert_return(() => invoke($14, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2643
+assert_return(() => invoke($14, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2644
+assert_return(() => invoke($14, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2645
+assert_return(() => invoke($14, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2646
+assert_return(() => invoke($14, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2647
+assert_return(() => invoke($14, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2648
+assert_return(() => invoke($14, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2649
+assert_return(() => invoke($14, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2650
+assert_return(() => invoke($14, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2651
+assert_return(() => invoke($14, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2652
+assert_return(() => invoke($14, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2653
+assert_return(() => invoke($14, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2654
+assert_return(() => invoke($14, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2655
+assert_return(() => invoke($14, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2656
+assert_return(() => invoke($14, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2657
+assert_return(() => invoke($14, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2658
+assert_return(() => invoke($14, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2659
+assert_return(() => invoke($14, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2660
+assert_return(() => invoke($14, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2661
+assert_return(() => invoke($14, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2662
+assert_return(() => invoke($14, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2663
+assert_return(() => invoke($14, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2664
+assert_return(() => invoke($14, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2665
+assert_return(() => invoke($14, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2666
+assert_return(() => invoke($14, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2667
+assert_return(() => invoke($14, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2668
+assert_return(() => invoke($14, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2669
+assert_return(() => invoke($14, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2670
+assert_return(() => invoke($14, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2671
+assert_return(() => invoke($14, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2672
+assert_return(() => invoke($14, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2673
+assert_return(() => invoke($14, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2674
+assert_return(() => invoke($14, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2675
+assert_return(() => invoke($14, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2676
+assert_return(() => invoke($14, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2677
+assert_return(() => invoke($14, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2678
+assert_return(() => invoke($14, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2679
+assert_return(() => invoke($14, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2680
+assert_return(() => invoke($14, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2681
+assert_return(() => invoke($14, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2682
+assert_return(() => invoke($14, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2683
+assert_return(() => invoke($14, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2684
+assert_return(() => invoke($14, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2685
+assert_return(() => invoke($14, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2686
+assert_return(() => invoke($14, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2687
+assert_return(() => invoke($14, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2688
+assert_return(() => invoke($14, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2689
+assert_return(() => invoke($14, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2690
+assert_return(() => invoke($14, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2691
+assert_return(() => invoke($14, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2692
+assert_return(() => invoke($14, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2693
+assert_return(() => invoke($14, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2694
+assert_return(() => invoke($14, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2695
+assert_return(() => invoke($14, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2696
+assert_return(() => invoke($14, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2697
+assert_return(() => invoke($14, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2698
+assert_return(() => invoke($14, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2699
+assert_return(() => invoke($14, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2700
+assert_return(() => invoke($14, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2701
+assert_return(() => invoke($14, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2702
+assert_return(() => invoke($14, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2703
+assert_return(() => invoke($14, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2704
+assert_return(() => invoke($14, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2705
+assert_return(() => invoke($14, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2706
+assert_return(() => invoke($14, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2707
+assert_return(() => invoke($14, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2708
+assert_return(() => invoke($14, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2709
+assert_return(() => invoke($14, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2710
+assert_return(() => invoke($14, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2711
+assert_return(() => invoke($14, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2712
+assert_return(() => invoke($14, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2713
+assert_return(() => invoke($14, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2714
+assert_return(() => invoke($14, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2715
+assert_return(() => invoke($14, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2716
+assert_return(() => invoke($14, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2717
+assert_return(() => invoke($14, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2718
+assert_return(() => invoke($14, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2719
+assert_return(() => invoke($14, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2720
+assert_return(() => invoke($14, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2721
+assert_return(() => invoke($14, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2722
+assert_return(() => invoke($14, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2723
+assert_return(() => invoke($14, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2724
+assert_return(() => invoke($14, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2725
+assert_return(() => invoke($14, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2726
+assert_return(() => invoke($14, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2727
+assert_return(() => invoke($14, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2728
+assert_return(() => invoke($14, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2729
+assert_return(() => invoke($14, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2730
+assert_return(() => invoke($14, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2731
+assert_return(() => invoke($14, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2732
+assert_return(() => invoke($14, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2733
+assert_return(() => invoke($14, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2734
+assert_return(() => invoke($14, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2735
+assert_return(() => invoke($14, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2736
+assert_return(() => invoke($14, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2737
+assert_return(() => invoke($14, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2738
+assert_return(() => invoke($14, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2739
+assert_return(() => invoke($14, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2740
+assert_return(() => invoke($14, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2741
+assert_return(() => invoke($14, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2742
+assert_return(() => invoke($14, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2743
+assert_return(() => invoke($14, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2744
+assert_return(() => invoke($14, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2745
+assert_return(() => invoke($14, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2746
+assert_return(() => invoke($14, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2747
+assert_return(() => invoke($14, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2748
+assert_return(() => invoke($14, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2749
+assert_return(() => invoke($14, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2750
+assert_return(() => invoke($14, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2751
+assert_return(() => invoke($14, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2752
+assert_return(() => invoke($14, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2753
+assert_return(() => invoke($14, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2754
+assert_return(() => invoke($14, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2755
+assert_return(() => invoke($14, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2756
+assert_return(() => invoke($14, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2757
+assert_return(() => invoke($14, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2758
+assert_return(() => invoke($14, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2759
+assert_return(() => invoke($14, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2760
+assert_return(() => invoke($14, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2761
+assert_return(() => invoke($14, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2762
+assert_return(() => invoke($14, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2763
+assert_return(() => invoke($14, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2764
+assert_return(() => invoke($14, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2765
+assert_return(() => invoke($14, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2766
+assert_return(() => invoke($14, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2767
+assert_return(() => invoke($14, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2768
+assert_return(() => invoke($14, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2769
+assert_return(() => invoke($14, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2770
+assert_return(() => invoke($14, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2771
+assert_return(() => invoke($14, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2772
+assert_return(() => invoke($14, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2773
+assert_return(() => invoke($14, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2774
+assert_return(() => invoke($14, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2775
+assert_return(() => invoke($14, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2776
+assert_return(() => invoke($14, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2777
+assert_return(() => invoke($14, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2778
+assert_return(() => invoke($14, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2779
+assert_return(() => invoke($14, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2780
+assert_return(() => invoke($14, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2781
+assert_return(() => invoke($14, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2782
+assert_return(() => invoke($14, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2783
+assert_return(() => invoke($14, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2784
+assert_return(() => invoke($14, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2785
+assert_return(() => invoke($14, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2786
+assert_return(() => invoke($14, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2787
+assert_return(() => invoke($14, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2788
+assert_return(() => invoke($14, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2789
+assert_return(() => invoke($14, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2790
+assert_return(() => invoke($14, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2791
+assert_return(() => invoke($14, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2792
+assert_return(() => invoke($14, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2793
+assert_return(() => invoke($14, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2794
+assert_return(() => invoke($14, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2795
+assert_return(() => invoke($14, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2796
+assert_return(() => invoke($14, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2797
+assert_return(() => invoke($14, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2798
+assert_return(() => invoke($14, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2799
+assert_return(() => invoke($14, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2800
+assert_return(() => invoke($14, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2801
+assert_return(() => invoke($14, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2802
+assert_return(() => invoke($14, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2803
+assert_return(() => invoke($14, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2804
+assert_return(() => invoke($14, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2805
+assert_return(() => invoke($14, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2806
+assert_return(() => invoke($14, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2807
+assert_return(() => invoke($14, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2808
+assert_return(() => invoke($14, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2809
+assert_return(() => invoke($14, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2810
+assert_return(() => invoke($14, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2811
+assert_return(() => invoke($14, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2812
+assert_return(() => invoke($14, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2813
+assert_return(() => invoke($14, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2814
+assert_return(() => invoke($14, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2815
+assert_return(() => invoke($14, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2816
+assert_return(() => invoke($14, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2817
+assert_return(() => invoke($14, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2818
+assert_return(() => invoke($14, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2819
+assert_return(() => invoke($14, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2820
+assert_return(() => invoke($14, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2821
+assert_return(() => invoke($14, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2822
+assert_return(() => invoke($14, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2823
+assert_return(() => invoke($14, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2824
+assert_return(() => invoke($14, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2825
+assert_return(() => invoke($14, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2826
+assert_return(() => invoke($14, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2827
+assert_return(() => invoke($14, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2828
+assert_return(() => invoke($14, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2829
+assert_return(() => invoke($14, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2830
+assert_return(() => invoke($14, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2831
+assert_return(() => invoke($14, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2832
+assert_return(() => invoke($14, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2833
+assert_return(() => invoke($14, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2834
+assert_return(() => invoke($14, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2835
+assert_return(() => invoke($14, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2836
+assert_return(() => invoke($14, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2837
+assert_return(() => invoke($14, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2838
+assert_return(() => invoke($14, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2839
+assert_return(() => invoke($14, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2840
+assert_return(() => invoke($14, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2841
+assert_return(() => invoke($14, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2842
+assert_return(() => invoke($14, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2843
+assert_return(() => invoke($14, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2844
+assert_return(() => invoke($14, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2845
+assert_return(() => invoke($14, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2846
+assert_return(() => invoke($14, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2847
+assert_return(() => invoke($14, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2848
+assert_return(() => invoke($14, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2849
+assert_return(() => invoke($14, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2850
+assert_return(() => invoke($14, `load8_u`, [65506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2851
+assert_return(() => invoke($14, `load8_u`, [65507]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:2852
+assert_return(() => invoke($14, `load8_u`, [65508]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:2853
+assert_return(() => invoke($14, `load8_u`, [65509]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:2854
+assert_return(() => invoke($14, `load8_u`, [65510]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:2855
+assert_return(() => invoke($14, `load8_u`, [65511]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:2856
+assert_return(() => invoke($14, `load8_u`, [65512]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:2857
+assert_return(() => invoke($14, `load8_u`, [65513]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:2858
+assert_return(() => invoke($14, `load8_u`, [65514]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:2859
+assert_return(() => invoke($14, `load8_u`, [65515]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:2860
+assert_return(() => invoke($14, `load8_u`, [65516]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:2861
+assert_return(() => invoke($14, `load8_u`, [65517]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:2862
+assert_return(() => invoke($14, `load8_u`, [65518]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:2863
+assert_return(() => invoke($14, `load8_u`, [65519]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:2864
+assert_return(() => invoke($14, `load8_u`, [65520]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:2865
+assert_return(() => invoke($14, `load8_u`, [65521]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:2866
+assert_return(() => invoke($14, `load8_u`, [65522]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:2867
+assert_return(() => invoke($14, `load8_u`, [65523]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:2868
+assert_return(() => invoke($14, `load8_u`, [65524]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:2869
+assert_return(() => invoke($14, `load8_u`, [65525]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:2871
+let $15 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:2879
+assert_trap(() => invoke($15, `run`, [65506, 65516, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:2882
+assert_return(() => invoke($15, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2883
+assert_return(() => invoke($15, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2884
+assert_return(() => invoke($15, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2885
+assert_return(() => invoke($15, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2886
+assert_return(() => invoke($15, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2887
+assert_return(() => invoke($15, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2888
+assert_return(() => invoke($15, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2889
+assert_return(() => invoke($15, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2890
+assert_return(() => invoke($15, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2891
+assert_return(() => invoke($15, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2892
+assert_return(() => invoke($15, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2893
+assert_return(() => invoke($15, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2894
+assert_return(() => invoke($15, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2895
+assert_return(() => invoke($15, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2896
+assert_return(() => invoke($15, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2897
+assert_return(() => invoke($15, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2898
+assert_return(() => invoke($15, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2899
+assert_return(() => invoke($15, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2900
+assert_return(() => invoke($15, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2901
+assert_return(() => invoke($15, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2902
+assert_return(() => invoke($15, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2903
+assert_return(() => invoke($15, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2904
+assert_return(() => invoke($15, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2905
+assert_return(() => invoke($15, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2906
+assert_return(() => invoke($15, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2907
+assert_return(() => invoke($15, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2908
+assert_return(() => invoke($15, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2909
+assert_return(() => invoke($15, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2910
+assert_return(() => invoke($15, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2911
+assert_return(() => invoke($15, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2912
+assert_return(() => invoke($15, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2913
+assert_return(() => invoke($15, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2914
+assert_return(() => invoke($15, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2915
+assert_return(() => invoke($15, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2916
+assert_return(() => invoke($15, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2917
+assert_return(() => invoke($15, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2918
+assert_return(() => invoke($15, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2919
+assert_return(() => invoke($15, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2920
+assert_return(() => invoke($15, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2921
+assert_return(() => invoke($15, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2922
+assert_return(() => invoke($15, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2923
+assert_return(() => invoke($15, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2924
+assert_return(() => invoke($15, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2925
+assert_return(() => invoke($15, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2926
+assert_return(() => invoke($15, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2927
+assert_return(() => invoke($15, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2928
+assert_return(() => invoke($15, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2929
+assert_return(() => invoke($15, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2930
+assert_return(() => invoke($15, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2931
+assert_return(() => invoke($15, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2932
+assert_return(() => invoke($15, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2933
+assert_return(() => invoke($15, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2934
+assert_return(() => invoke($15, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2935
+assert_return(() => invoke($15, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2936
+assert_return(() => invoke($15, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2937
+assert_return(() => invoke($15, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2938
+assert_return(() => invoke($15, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2939
+assert_return(() => invoke($15, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2940
+assert_return(() => invoke($15, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2941
+assert_return(() => invoke($15, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2942
+assert_return(() => invoke($15, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2943
+assert_return(() => invoke($15, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2944
+assert_return(() => invoke($15, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2945
+assert_return(() => invoke($15, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2946
+assert_return(() => invoke($15, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2947
+assert_return(() => invoke($15, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2948
+assert_return(() => invoke($15, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2949
+assert_return(() => invoke($15, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2950
+assert_return(() => invoke($15, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2951
+assert_return(() => invoke($15, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2952
+assert_return(() => invoke($15, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2953
+assert_return(() => invoke($15, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2954
+assert_return(() => invoke($15, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2955
+assert_return(() => invoke($15, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2956
+assert_return(() => invoke($15, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2957
+assert_return(() => invoke($15, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2958
+assert_return(() => invoke($15, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2959
+assert_return(() => invoke($15, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2960
+assert_return(() => invoke($15, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2961
+assert_return(() => invoke($15, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2962
+assert_return(() => invoke($15, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2963
+assert_return(() => invoke($15, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2964
+assert_return(() => invoke($15, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2965
+assert_return(() => invoke($15, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2966
+assert_return(() => invoke($15, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2967
+assert_return(() => invoke($15, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2968
+assert_return(() => invoke($15, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2969
+assert_return(() => invoke($15, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2970
+assert_return(() => invoke($15, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2971
+assert_return(() => invoke($15, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2972
+assert_return(() => invoke($15, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2973
+assert_return(() => invoke($15, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2974
+assert_return(() => invoke($15, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2975
+assert_return(() => invoke($15, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2976
+assert_return(() => invoke($15, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2977
+assert_return(() => invoke($15, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2978
+assert_return(() => invoke($15, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2979
+assert_return(() => invoke($15, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2980
+assert_return(() => invoke($15, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2981
+assert_return(() => invoke($15, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2982
+assert_return(() => invoke($15, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2983
+assert_return(() => invoke($15, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2984
+assert_return(() => invoke($15, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2985
+assert_return(() => invoke($15, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2986
+assert_return(() => invoke($15, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2987
+assert_return(() => invoke($15, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2988
+assert_return(() => invoke($15, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2989
+assert_return(() => invoke($15, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2990
+assert_return(() => invoke($15, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2991
+assert_return(() => invoke($15, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2992
+assert_return(() => invoke($15, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2993
+assert_return(() => invoke($15, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2994
+assert_return(() => invoke($15, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2995
+assert_return(() => invoke($15, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2996
+assert_return(() => invoke($15, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2997
+assert_return(() => invoke($15, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2998
+assert_return(() => invoke($15, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:2999
+assert_return(() => invoke($15, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3000
+assert_return(() => invoke($15, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3001
+assert_return(() => invoke($15, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3002
+assert_return(() => invoke($15, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3003
+assert_return(() => invoke($15, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3004
+assert_return(() => invoke($15, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3005
+assert_return(() => invoke($15, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3006
+assert_return(() => invoke($15, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3007
+assert_return(() => invoke($15, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3008
+assert_return(() => invoke($15, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3009
+assert_return(() => invoke($15, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3010
+assert_return(() => invoke($15, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3011
+assert_return(() => invoke($15, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3012
+assert_return(() => invoke($15, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3013
+assert_return(() => invoke($15, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3014
+assert_return(() => invoke($15, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3015
+assert_return(() => invoke($15, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3016
+assert_return(() => invoke($15, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3017
+assert_return(() => invoke($15, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3018
+assert_return(() => invoke($15, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3019
+assert_return(() => invoke($15, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3020
+assert_return(() => invoke($15, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3021
+assert_return(() => invoke($15, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3022
+assert_return(() => invoke($15, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3023
+assert_return(() => invoke($15, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3024
+assert_return(() => invoke($15, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3025
+assert_return(() => invoke($15, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3026
+assert_return(() => invoke($15, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3027
+assert_return(() => invoke($15, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3028
+assert_return(() => invoke($15, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3029
+assert_return(() => invoke($15, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3030
+assert_return(() => invoke($15, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3031
+assert_return(() => invoke($15, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3032
+assert_return(() => invoke($15, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3033
+assert_return(() => invoke($15, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3034
+assert_return(() => invoke($15, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3035
+assert_return(() => invoke($15, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3036
+assert_return(() => invoke($15, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3037
+assert_return(() => invoke($15, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3038
+assert_return(() => invoke($15, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3039
+assert_return(() => invoke($15, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3040
+assert_return(() => invoke($15, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3041
+assert_return(() => invoke($15, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3042
+assert_return(() => invoke($15, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3043
+assert_return(() => invoke($15, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3044
+assert_return(() => invoke($15, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3045
+assert_return(() => invoke($15, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3046
+assert_return(() => invoke($15, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3047
+assert_return(() => invoke($15, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3048
+assert_return(() => invoke($15, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3049
+assert_return(() => invoke($15, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3050
+assert_return(() => invoke($15, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3051
+assert_return(() => invoke($15, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3052
+assert_return(() => invoke($15, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3053
+assert_return(() => invoke($15, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3054
+assert_return(() => invoke($15, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3055
+assert_return(() => invoke($15, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3056
+assert_return(() => invoke($15, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3057
+assert_return(() => invoke($15, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3058
+assert_return(() => invoke($15, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3059
+assert_return(() => invoke($15, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3060
+assert_return(() => invoke($15, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3061
+assert_return(() => invoke($15, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3062
+assert_return(() => invoke($15, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3063
+assert_return(() => invoke($15, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3064
+assert_return(() => invoke($15, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3065
+assert_return(() => invoke($15, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3066
+assert_return(() => invoke($15, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3067
+assert_return(() => invoke($15, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3068
+assert_return(() => invoke($15, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3069
+assert_return(() => invoke($15, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3070
+assert_return(() => invoke($15, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3071
+assert_return(() => invoke($15, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3072
+assert_return(() => invoke($15, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3073
+assert_return(() => invoke($15, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3074
+assert_return(() => invoke($15, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3075
+assert_return(() => invoke($15, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3076
+assert_return(() => invoke($15, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3077
+assert_return(() => invoke($15, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3078
+assert_return(() => invoke($15, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3079
+assert_return(() => invoke($15, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3080
+assert_return(() => invoke($15, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3081
+assert_return(() => invoke($15, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3082
+assert_return(() => invoke($15, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3083
+assert_return(() => invoke($15, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3084
+assert_return(() => invoke($15, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3085
+assert_return(() => invoke($15, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3086
+assert_return(() => invoke($15, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3087
+assert_return(() => invoke($15, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3088
+assert_return(() => invoke($15, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3089
+assert_return(() => invoke($15, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3090
+assert_return(() => invoke($15, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3091
+assert_return(() => invoke($15, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3092
+assert_return(() => invoke($15, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3093
+assert_return(() => invoke($15, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3094
+assert_return(() => invoke($15, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3095
+assert_return(() => invoke($15, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3096
+assert_return(() => invoke($15, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3097
+assert_return(() => invoke($15, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3098
+assert_return(() => invoke($15, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3099
+assert_return(() => invoke($15, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3100
+assert_return(() => invoke($15, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3101
+assert_return(() => invoke($15, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3102
+assert_return(() => invoke($15, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3103
+assert_return(() => invoke($15, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3104
+assert_return(() => invoke($15, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3105
+assert_return(() => invoke($15, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3106
+assert_return(() => invoke($15, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3107
+assert_return(() => invoke($15, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3108
+assert_return(() => invoke($15, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3109
+assert_return(() => invoke($15, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3110
+assert_return(() => invoke($15, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3111
+assert_return(() => invoke($15, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3112
+assert_return(() => invoke($15, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3113
+assert_return(() => invoke($15, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3114
+assert_return(() => invoke($15, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3115
+assert_return(() => invoke($15, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3116
+assert_return(() => invoke($15, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3117
+assert_return(() => invoke($15, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3118
+assert_return(() => invoke($15, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3119
+assert_return(() => invoke($15, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3120
+assert_return(() => invoke($15, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3121
+assert_return(() => invoke($15, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3122
+assert_return(() => invoke($15, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3123
+assert_return(() => invoke($15, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3124
+assert_return(() => invoke($15, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3125
+assert_return(() => invoke($15, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3126
+assert_return(() => invoke($15, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3127
+assert_return(() => invoke($15, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3128
+assert_return(() => invoke($15, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3129
+assert_return(() => invoke($15, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3130
+assert_return(() => invoke($15, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3131
+assert_return(() => invoke($15, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3132
+assert_return(() => invoke($15, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3133
+assert_return(() => invoke($15, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3134
+assert_return(() => invoke($15, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3135
+assert_return(() => invoke($15, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3136
+assert_return(() => invoke($15, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3137
+assert_return(() => invoke($15, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3138
+assert_return(() => invoke($15, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3139
+assert_return(() => invoke($15, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3140
+assert_return(() => invoke($15, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3141
+assert_return(() => invoke($15, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3142
+assert_return(() => invoke($15, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3143
+assert_return(() => invoke($15, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3144
+assert_return(() => invoke($15, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3145
+assert_return(() => invoke($15, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3146
+assert_return(() => invoke($15, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3147
+assert_return(() => invoke($15, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3148
+assert_return(() => invoke($15, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3149
+assert_return(() => invoke($15, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3150
+assert_return(() => invoke($15, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3151
+assert_return(() => invoke($15, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3152
+assert_return(() => invoke($15, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3153
+assert_return(() => invoke($15, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3154
+assert_return(() => invoke($15, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3155
+assert_return(() => invoke($15, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3156
+assert_return(() => invoke($15, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3157
+assert_return(() => invoke($15, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3158
+assert_return(() => invoke($15, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3159
+assert_return(() => invoke($15, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3160
+assert_return(() => invoke($15, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3161
+assert_return(() => invoke($15, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3162
+assert_return(() => invoke($15, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3163
+assert_return(() => invoke($15, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3164
+assert_return(() => invoke($15, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3165
+assert_return(() => invoke($15, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3166
+assert_return(() => invoke($15, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3167
+assert_return(() => invoke($15, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3168
+assert_return(() => invoke($15, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3169
+assert_return(() => invoke($15, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3170
+assert_return(() => invoke($15, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3171
+assert_return(() => invoke($15, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3172
+assert_return(() => invoke($15, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3173
+assert_return(() => invoke($15, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3174
+assert_return(() => invoke($15, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3175
+assert_return(() => invoke($15, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3176
+assert_return(() => invoke($15, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3177
+assert_return(() => invoke($15, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3178
+assert_return(() => invoke($15, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3179
+assert_return(() => invoke($15, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3180
+assert_return(() => invoke($15, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3181
+assert_return(() => invoke($15, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3182
+assert_return(() => invoke($15, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3183
+assert_return(() => invoke($15, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3184
+assert_return(() => invoke($15, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3185
+assert_return(() => invoke($15, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3186
+assert_return(() => invoke($15, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3187
+assert_return(() => invoke($15, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3188
+assert_return(() => invoke($15, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3189
+assert_return(() => invoke($15, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3190
+assert_return(() => invoke($15, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3191
+assert_return(() => invoke($15, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3192
+assert_return(() => invoke($15, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3193
+assert_return(() => invoke($15, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3194
+assert_return(() => invoke($15, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3195
+assert_return(() => invoke($15, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3196
+assert_return(() => invoke($15, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3197
+assert_return(() => invoke($15, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3198
+assert_return(() => invoke($15, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3199
+assert_return(() => invoke($15, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3200
+assert_return(() => invoke($15, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3201
+assert_return(() => invoke($15, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3202
+assert_return(() => invoke($15, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3203
+assert_return(() => invoke($15, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3204
+assert_return(() => invoke($15, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3205
+assert_return(() => invoke($15, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3206
+assert_return(() => invoke($15, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3207
+assert_return(() => invoke($15, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3208
+assert_return(() => invoke($15, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3209
+assert_return(() => invoke($15, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3210
+assert_return(() => invoke($15, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3211
+assert_return(() => invoke($15, `load8_u`, [65516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3212
+assert_return(() => invoke($15, `load8_u`, [65517]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:3213
+assert_return(() => invoke($15, `load8_u`, [65518]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:3214
+assert_return(() => invoke($15, `load8_u`, [65519]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:3215
+assert_return(() => invoke($15, `load8_u`, [65520]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:3216
+assert_return(() => invoke($15, `load8_u`, [65521]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:3217
+assert_return(() => invoke($15, `load8_u`, [65522]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:3218
+assert_return(() => invoke($15, `load8_u`, [65523]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:3219
+assert_return(() => invoke($15, `load8_u`, [65524]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:3220
+assert_return(() => invoke($15, `load8_u`, [65525]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:3221
+assert_return(() => invoke($15, `load8_u`, [65526]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:3222
+assert_return(() => invoke($15, `load8_u`, [65527]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:3223
+assert_return(() => invoke($15, `load8_u`, [65528]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:3224
+assert_return(() => invoke($15, `load8_u`, [65529]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:3225
+assert_return(() => invoke($15, `load8_u`, [65530]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:3226
+assert_return(() => invoke($15, `load8_u`, [65531]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:3227
+assert_return(() => invoke($15, `load8_u`, [65532]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:3228
+assert_return(() => invoke($15, `load8_u`, [65533]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:3229
+assert_return(() => invoke($15, `load8_u`, [65534]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:3230
+assert_return(() => invoke($15, `load8_u`, [65535]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:3232
+let $16 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:3240
+assert_trap(() => invoke($16, `run`, [65516, 65516, 40]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:3243
+assert_return(() => invoke($16, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3244
+assert_return(() => invoke($16, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3245
+assert_return(() => invoke($16, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3246
+assert_return(() => invoke($16, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3247
+assert_return(() => invoke($16, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3248
+assert_return(() => invoke($16, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3249
+assert_return(() => invoke($16, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3250
+assert_return(() => invoke($16, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3251
+assert_return(() => invoke($16, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3252
+assert_return(() => invoke($16, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3253
+assert_return(() => invoke($16, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3254
+assert_return(() => invoke($16, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3255
+assert_return(() => invoke($16, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3256
+assert_return(() => invoke($16, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3257
+assert_return(() => invoke($16, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3258
+assert_return(() => invoke($16, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3259
+assert_return(() => invoke($16, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3260
+assert_return(() => invoke($16, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3261
+assert_return(() => invoke($16, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3262
+assert_return(() => invoke($16, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3263
+assert_return(() => invoke($16, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3264
+assert_return(() => invoke($16, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3265
+assert_return(() => invoke($16, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3266
+assert_return(() => invoke($16, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3267
+assert_return(() => invoke($16, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3268
+assert_return(() => invoke($16, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3269
+assert_return(() => invoke($16, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3270
+assert_return(() => invoke($16, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3271
+assert_return(() => invoke($16, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3272
+assert_return(() => invoke($16, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3273
+assert_return(() => invoke($16, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3274
+assert_return(() => invoke($16, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3275
+assert_return(() => invoke($16, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3276
+assert_return(() => invoke($16, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3277
+assert_return(() => invoke($16, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3278
+assert_return(() => invoke($16, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3279
+assert_return(() => invoke($16, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3280
+assert_return(() => invoke($16, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3281
+assert_return(() => invoke($16, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3282
+assert_return(() => invoke($16, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3283
+assert_return(() => invoke($16, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3284
+assert_return(() => invoke($16, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3285
+assert_return(() => invoke($16, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3286
+assert_return(() => invoke($16, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3287
+assert_return(() => invoke($16, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3288
+assert_return(() => invoke($16, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3289
+assert_return(() => invoke($16, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3290
+assert_return(() => invoke($16, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3291
+assert_return(() => invoke($16, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3292
+assert_return(() => invoke($16, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3293
+assert_return(() => invoke($16, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3294
+assert_return(() => invoke($16, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3295
+assert_return(() => invoke($16, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3296
+assert_return(() => invoke($16, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3297
+assert_return(() => invoke($16, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3298
+assert_return(() => invoke($16, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3299
+assert_return(() => invoke($16, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3300
+assert_return(() => invoke($16, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3301
+assert_return(() => invoke($16, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3302
+assert_return(() => invoke($16, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3303
+assert_return(() => invoke($16, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3304
+assert_return(() => invoke($16, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3305
+assert_return(() => invoke($16, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3306
+assert_return(() => invoke($16, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3307
+assert_return(() => invoke($16, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3308
+assert_return(() => invoke($16, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3309
+assert_return(() => invoke($16, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3310
+assert_return(() => invoke($16, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3311
+assert_return(() => invoke($16, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3312
+assert_return(() => invoke($16, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3313
+assert_return(() => invoke($16, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3314
+assert_return(() => invoke($16, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3315
+assert_return(() => invoke($16, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3316
+assert_return(() => invoke($16, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3317
+assert_return(() => invoke($16, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3318
+assert_return(() => invoke($16, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3319
+assert_return(() => invoke($16, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3320
+assert_return(() => invoke($16, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3321
+assert_return(() => invoke($16, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3322
+assert_return(() => invoke($16, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3323
+assert_return(() => invoke($16, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3324
+assert_return(() => invoke($16, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3325
+assert_return(() => invoke($16, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3326
+assert_return(() => invoke($16, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3327
+assert_return(() => invoke($16, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3328
+assert_return(() => invoke($16, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3329
+assert_return(() => invoke($16, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3330
+assert_return(() => invoke($16, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3331
+assert_return(() => invoke($16, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3332
+assert_return(() => invoke($16, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3333
+assert_return(() => invoke($16, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3334
+assert_return(() => invoke($16, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3335
+assert_return(() => invoke($16, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3336
+assert_return(() => invoke($16, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3337
+assert_return(() => invoke($16, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3338
+assert_return(() => invoke($16, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3339
+assert_return(() => invoke($16, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3340
+assert_return(() => invoke($16, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3341
+assert_return(() => invoke($16, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3342
+assert_return(() => invoke($16, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3343
+assert_return(() => invoke($16, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3344
+assert_return(() => invoke($16, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3345
+assert_return(() => invoke($16, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3346
+assert_return(() => invoke($16, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3347
+assert_return(() => invoke($16, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3348
+assert_return(() => invoke($16, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3349
+assert_return(() => invoke($16, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3350
+assert_return(() => invoke($16, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3351
+assert_return(() => invoke($16, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3352
+assert_return(() => invoke($16, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3353
+assert_return(() => invoke($16, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3354
+assert_return(() => invoke($16, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3355
+assert_return(() => invoke($16, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3356
+assert_return(() => invoke($16, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3357
+assert_return(() => invoke($16, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3358
+assert_return(() => invoke($16, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3359
+assert_return(() => invoke($16, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3360
+assert_return(() => invoke($16, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3361
+assert_return(() => invoke($16, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3362
+assert_return(() => invoke($16, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3363
+assert_return(() => invoke($16, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3364
+assert_return(() => invoke($16, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3365
+assert_return(() => invoke($16, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3366
+assert_return(() => invoke($16, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3367
+assert_return(() => invoke($16, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3368
+assert_return(() => invoke($16, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3369
+assert_return(() => invoke($16, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3370
+assert_return(() => invoke($16, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3371
+assert_return(() => invoke($16, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3372
+assert_return(() => invoke($16, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3373
+assert_return(() => invoke($16, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3374
+assert_return(() => invoke($16, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3375
+assert_return(() => invoke($16, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3376
+assert_return(() => invoke($16, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3377
+assert_return(() => invoke($16, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3378
+assert_return(() => invoke($16, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3379
+assert_return(() => invoke($16, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3380
+assert_return(() => invoke($16, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3381
+assert_return(() => invoke($16, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3382
+assert_return(() => invoke($16, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3383
+assert_return(() => invoke($16, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3384
+assert_return(() => invoke($16, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3385
+assert_return(() => invoke($16, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3386
+assert_return(() => invoke($16, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3387
+assert_return(() => invoke($16, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3388
+assert_return(() => invoke($16, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3389
+assert_return(() => invoke($16, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3390
+assert_return(() => invoke($16, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3391
+assert_return(() => invoke($16, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3392
+assert_return(() => invoke($16, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3393
+assert_return(() => invoke($16, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3394
+assert_return(() => invoke($16, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3395
+assert_return(() => invoke($16, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3396
+assert_return(() => invoke($16, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3397
+assert_return(() => invoke($16, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3398
+assert_return(() => invoke($16, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3399
+assert_return(() => invoke($16, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3400
+assert_return(() => invoke($16, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3401
+assert_return(() => invoke($16, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3402
+assert_return(() => invoke($16, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3403
+assert_return(() => invoke($16, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3404
+assert_return(() => invoke($16, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3405
+assert_return(() => invoke($16, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3406
+assert_return(() => invoke($16, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3407
+assert_return(() => invoke($16, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3408
+assert_return(() => invoke($16, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3409
+assert_return(() => invoke($16, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3410
+assert_return(() => invoke($16, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3411
+assert_return(() => invoke($16, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3412
+assert_return(() => invoke($16, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3413
+assert_return(() => invoke($16, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3414
+assert_return(() => invoke($16, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3415
+assert_return(() => invoke($16, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3416
+assert_return(() => invoke($16, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3417
+assert_return(() => invoke($16, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3418
+assert_return(() => invoke($16, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3419
+assert_return(() => invoke($16, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3420
+assert_return(() => invoke($16, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3421
+assert_return(() => invoke($16, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3422
+assert_return(() => invoke($16, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3423
+assert_return(() => invoke($16, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3424
+assert_return(() => invoke($16, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3425
+assert_return(() => invoke($16, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3426
+assert_return(() => invoke($16, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3427
+assert_return(() => invoke($16, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3428
+assert_return(() => invoke($16, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3429
+assert_return(() => invoke($16, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3430
+assert_return(() => invoke($16, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3431
+assert_return(() => invoke($16, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3432
+assert_return(() => invoke($16, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3433
+assert_return(() => invoke($16, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3434
+assert_return(() => invoke($16, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3435
+assert_return(() => invoke($16, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3436
+assert_return(() => invoke($16, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3437
+assert_return(() => invoke($16, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3438
+assert_return(() => invoke($16, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3439
+assert_return(() => invoke($16, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3440
+assert_return(() => invoke($16, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3441
+assert_return(() => invoke($16, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3442
+assert_return(() => invoke($16, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3443
+assert_return(() => invoke($16, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3444
+assert_return(() => invoke($16, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3445
+assert_return(() => invoke($16, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3446
+assert_return(() => invoke($16, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3447
+assert_return(() => invoke($16, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3448
+assert_return(() => invoke($16, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3449
+assert_return(() => invoke($16, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3450
+assert_return(() => invoke($16, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3451
+assert_return(() => invoke($16, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3452
+assert_return(() => invoke($16, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3453
+assert_return(() => invoke($16, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3454
+assert_return(() => invoke($16, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3455
+assert_return(() => invoke($16, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3456
+assert_return(() => invoke($16, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3457
+assert_return(() => invoke($16, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3458
+assert_return(() => invoke($16, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3459
+assert_return(() => invoke($16, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3460
+assert_return(() => invoke($16, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3461
+assert_return(() => invoke($16, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3462
+assert_return(() => invoke($16, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3463
+assert_return(() => invoke($16, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3464
+assert_return(() => invoke($16, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3465
+assert_return(() => invoke($16, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3466
+assert_return(() => invoke($16, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3467
+assert_return(() => invoke($16, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3468
+assert_return(() => invoke($16, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3469
+assert_return(() => invoke($16, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3470
+assert_return(() => invoke($16, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3471
+assert_return(() => invoke($16, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3472
+assert_return(() => invoke($16, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3473
+assert_return(() => invoke($16, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3474
+assert_return(() => invoke($16, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3475
+assert_return(() => invoke($16, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3476
+assert_return(() => invoke($16, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3477
+assert_return(() => invoke($16, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3478
+assert_return(() => invoke($16, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3479
+assert_return(() => invoke($16, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3480
+assert_return(() => invoke($16, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3481
+assert_return(() => invoke($16, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3482
+assert_return(() => invoke($16, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3483
+assert_return(() => invoke($16, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3484
+assert_return(() => invoke($16, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3485
+assert_return(() => invoke($16, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3486
+assert_return(() => invoke($16, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3487
+assert_return(() => invoke($16, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3488
+assert_return(() => invoke($16, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3489
+assert_return(() => invoke($16, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3490
+assert_return(() => invoke($16, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3491
+assert_return(() => invoke($16, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3492
+assert_return(() => invoke($16, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3493
+assert_return(() => invoke($16, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3494
+assert_return(() => invoke($16, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3495
+assert_return(() => invoke($16, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3496
+assert_return(() => invoke($16, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3497
+assert_return(() => invoke($16, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3498
+assert_return(() => invoke($16, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3499
+assert_return(() => invoke($16, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3500
+assert_return(() => invoke($16, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3501
+assert_return(() => invoke($16, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3502
+assert_return(() => invoke($16, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3503
+assert_return(() => invoke($16, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3504
+assert_return(() => invoke($16, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3505
+assert_return(() => invoke($16, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3506
+assert_return(() => invoke($16, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3507
+assert_return(() => invoke($16, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3508
+assert_return(() => invoke($16, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3509
+assert_return(() => invoke($16, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3510
+assert_return(() => invoke($16, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3511
+assert_return(() => invoke($16, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3512
+assert_return(() => invoke($16, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3513
+assert_return(() => invoke($16, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3514
+assert_return(() => invoke($16, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3515
+assert_return(() => invoke($16, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3516
+assert_return(() => invoke($16, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3517
+assert_return(() => invoke($16, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3518
+assert_return(() => invoke($16, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3519
+assert_return(() => invoke($16, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3520
+assert_return(() => invoke($16, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3521
+assert_return(() => invoke($16, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3522
+assert_return(() => invoke($16, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3523
+assert_return(() => invoke($16, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3524
+assert_return(() => invoke($16, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3525
+assert_return(() => invoke($16, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3526
+assert_return(() => invoke($16, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3527
+assert_return(() => invoke($16, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3528
+assert_return(() => invoke($16, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3529
+assert_return(() => invoke($16, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3530
+assert_return(() => invoke($16, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3531
+assert_return(() => invoke($16, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3532
+assert_return(() => invoke($16, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3533
+assert_return(() => invoke($16, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3534
+assert_return(() => invoke($16, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3535
+assert_return(() => invoke($16, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3536
+assert_return(() => invoke($16, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3537
+assert_return(() => invoke($16, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3538
+assert_return(() => invoke($16, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3539
+assert_return(() => invoke($16, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3540
+assert_return(() => invoke($16, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3541
+assert_return(() => invoke($16, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3542
+assert_return(() => invoke($16, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3543
+assert_return(() => invoke($16, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3544
+assert_return(() => invoke($16, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3545
+assert_return(() => invoke($16, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3546
+assert_return(() => invoke($16, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3547
+assert_return(() => invoke($16, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3548
+assert_return(() => invoke($16, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3549
+assert_return(() => invoke($16, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3550
+assert_return(() => invoke($16, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3551
+assert_return(() => invoke($16, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3552
+assert_return(() => invoke($16, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3553
+assert_return(() => invoke($16, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3554
+assert_return(() => invoke($16, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3555
+assert_return(() => invoke($16, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3556
+assert_return(() => invoke($16, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3557
+assert_return(() => invoke($16, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3558
+assert_return(() => invoke($16, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3559
+assert_return(() => invoke($16, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3560
+assert_return(() => invoke($16, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3561
+assert_return(() => invoke($16, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3562
+assert_return(() => invoke($16, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3563
+assert_return(() => invoke($16, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3564
+assert_return(() => invoke($16, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3565
+assert_return(() => invoke($16, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3566
+assert_return(() => invoke($16, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3567
+assert_return(() => invoke($16, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3568
+assert_return(() => invoke($16, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3569
+assert_return(() => invoke($16, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3570
+assert_return(() => invoke($16, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3571
+assert_return(() => invoke($16, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3572
+assert_return(() => invoke($16, `load8_u`, [65516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3573
+assert_return(() => invoke($16, `load8_u`, [65517]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:3574
+assert_return(() => invoke($16, `load8_u`, [65518]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:3575
+assert_return(() => invoke($16, `load8_u`, [65519]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:3576
+assert_return(() => invoke($16, `load8_u`, [65520]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:3577
+assert_return(() => invoke($16, `load8_u`, [65521]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:3578
+assert_return(() => invoke($16, `load8_u`, [65522]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:3579
+assert_return(() => invoke($16, `load8_u`, [65523]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:3580
+assert_return(() => invoke($16, `load8_u`, [65524]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:3581
+assert_return(() => invoke($16, `load8_u`, [65525]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:3582
+assert_return(() => invoke($16, `load8_u`, [65526]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:3583
+assert_return(() => invoke($16, `load8_u`, [65527]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:3584
+assert_return(() => invoke($16, `load8_u`, [65528]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:3585
+assert_return(() => invoke($16, `load8_u`, [65529]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:3586
+assert_return(() => invoke($16, `load8_u`, [65530]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:3587
+assert_return(() => invoke($16, `load8_u`, [65531]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:3588
+assert_return(() => invoke($16, `load8_u`, [65532]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:3589
+assert_return(() => invoke($16, `load8_u`, [65533]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:3590
+assert_return(() => invoke($16, `load8_u`, [65534]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:3591
+assert_return(() => invoke($16, `load8_u`, [65535]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:3593
+let $17 = instantiate(`(module
+  (memory (export "mem") 1  )
+  (data (i32.const 65516) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:3601
+assert_trap(() => invoke($17, `run`, [0, 65516, -4096]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:3604
+assert_return(() => invoke($17, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3605
+assert_return(() => invoke($17, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3606
+assert_return(() => invoke($17, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3607
+assert_return(() => invoke($17, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3608
+assert_return(() => invoke($17, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3609
+assert_return(() => invoke($17, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3610
+assert_return(() => invoke($17, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3611
+assert_return(() => invoke($17, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3612
+assert_return(() => invoke($17, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3613
+assert_return(() => invoke($17, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3614
+assert_return(() => invoke($17, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3615
+assert_return(() => invoke($17, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3616
+assert_return(() => invoke($17, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3617
+assert_return(() => invoke($17, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3618
+assert_return(() => invoke($17, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3619
+assert_return(() => invoke($17, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3620
+assert_return(() => invoke($17, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3621
+assert_return(() => invoke($17, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3622
+assert_return(() => invoke($17, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3623
+assert_return(() => invoke($17, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3624
+assert_return(() => invoke($17, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3625
+assert_return(() => invoke($17, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3626
+assert_return(() => invoke($17, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3627
+assert_return(() => invoke($17, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3628
+assert_return(() => invoke($17, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3629
+assert_return(() => invoke($17, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3630
+assert_return(() => invoke($17, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3631
+assert_return(() => invoke($17, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3632
+assert_return(() => invoke($17, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3633
+assert_return(() => invoke($17, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3634
+assert_return(() => invoke($17, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3635
+assert_return(() => invoke($17, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3636
+assert_return(() => invoke($17, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3637
+assert_return(() => invoke($17, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3638
+assert_return(() => invoke($17, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3639
+assert_return(() => invoke($17, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3640
+assert_return(() => invoke($17, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3641
+assert_return(() => invoke($17, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3642
+assert_return(() => invoke($17, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3643
+assert_return(() => invoke($17, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3644
+assert_return(() => invoke($17, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3645
+assert_return(() => invoke($17, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3646
+assert_return(() => invoke($17, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3647
+assert_return(() => invoke($17, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3648
+assert_return(() => invoke($17, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3649
+assert_return(() => invoke($17, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3650
+assert_return(() => invoke($17, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3651
+assert_return(() => invoke($17, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3652
+assert_return(() => invoke($17, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3653
+assert_return(() => invoke($17, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3654
+assert_return(() => invoke($17, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3655
+assert_return(() => invoke($17, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3656
+assert_return(() => invoke($17, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3657
+assert_return(() => invoke($17, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3658
+assert_return(() => invoke($17, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3659
+assert_return(() => invoke($17, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3660
+assert_return(() => invoke($17, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3661
+assert_return(() => invoke($17, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3662
+assert_return(() => invoke($17, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3663
+assert_return(() => invoke($17, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3664
+assert_return(() => invoke($17, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3665
+assert_return(() => invoke($17, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3666
+assert_return(() => invoke($17, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3667
+assert_return(() => invoke($17, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3668
+assert_return(() => invoke($17, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3669
+assert_return(() => invoke($17, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3670
+assert_return(() => invoke($17, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3671
+assert_return(() => invoke($17, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3672
+assert_return(() => invoke($17, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3673
+assert_return(() => invoke($17, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3674
+assert_return(() => invoke($17, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3675
+assert_return(() => invoke($17, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3676
+assert_return(() => invoke($17, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3677
+assert_return(() => invoke($17, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3678
+assert_return(() => invoke($17, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3679
+assert_return(() => invoke($17, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3680
+assert_return(() => invoke($17, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3681
+assert_return(() => invoke($17, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3682
+assert_return(() => invoke($17, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3683
+assert_return(() => invoke($17, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3684
+assert_return(() => invoke($17, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3685
+assert_return(() => invoke($17, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3686
+assert_return(() => invoke($17, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3687
+assert_return(() => invoke($17, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3688
+assert_return(() => invoke($17, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3689
+assert_return(() => invoke($17, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3690
+assert_return(() => invoke($17, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3691
+assert_return(() => invoke($17, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3692
+assert_return(() => invoke($17, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3693
+assert_return(() => invoke($17, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3694
+assert_return(() => invoke($17, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3695
+assert_return(() => invoke($17, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3696
+assert_return(() => invoke($17, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3697
+assert_return(() => invoke($17, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3698
+assert_return(() => invoke($17, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3699
+assert_return(() => invoke($17, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3700
+assert_return(() => invoke($17, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3701
+assert_return(() => invoke($17, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3702
+assert_return(() => invoke($17, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3703
+assert_return(() => invoke($17, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3704
+assert_return(() => invoke($17, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3705
+assert_return(() => invoke($17, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3706
+assert_return(() => invoke($17, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3707
+assert_return(() => invoke($17, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3708
+assert_return(() => invoke($17, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3709
+assert_return(() => invoke($17, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3710
+assert_return(() => invoke($17, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3711
+assert_return(() => invoke($17, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3712
+assert_return(() => invoke($17, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3713
+assert_return(() => invoke($17, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3714
+assert_return(() => invoke($17, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3715
+assert_return(() => invoke($17, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3716
+assert_return(() => invoke($17, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3717
+assert_return(() => invoke($17, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3718
+assert_return(() => invoke($17, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3719
+assert_return(() => invoke($17, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3720
+assert_return(() => invoke($17, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3721
+assert_return(() => invoke($17, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3722
+assert_return(() => invoke($17, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3723
+assert_return(() => invoke($17, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3724
+assert_return(() => invoke($17, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3725
+assert_return(() => invoke($17, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3726
+assert_return(() => invoke($17, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3727
+assert_return(() => invoke($17, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3728
+assert_return(() => invoke($17, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3729
+assert_return(() => invoke($17, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3730
+assert_return(() => invoke($17, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3731
+assert_return(() => invoke($17, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3732
+assert_return(() => invoke($17, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3733
+assert_return(() => invoke($17, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3734
+assert_return(() => invoke($17, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3735
+assert_return(() => invoke($17, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3736
+assert_return(() => invoke($17, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3737
+assert_return(() => invoke($17, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3738
+assert_return(() => invoke($17, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3739
+assert_return(() => invoke($17, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3740
+assert_return(() => invoke($17, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3741
+assert_return(() => invoke($17, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3742
+assert_return(() => invoke($17, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3743
+assert_return(() => invoke($17, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3744
+assert_return(() => invoke($17, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3745
+assert_return(() => invoke($17, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3746
+assert_return(() => invoke($17, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3747
+assert_return(() => invoke($17, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3748
+assert_return(() => invoke($17, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3749
+assert_return(() => invoke($17, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3750
+assert_return(() => invoke($17, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3751
+assert_return(() => invoke($17, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3752
+assert_return(() => invoke($17, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3753
+assert_return(() => invoke($17, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3754
+assert_return(() => invoke($17, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3755
+assert_return(() => invoke($17, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3756
+assert_return(() => invoke($17, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3757
+assert_return(() => invoke($17, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3758
+assert_return(() => invoke($17, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3759
+assert_return(() => invoke($17, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3760
+assert_return(() => invoke($17, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3761
+assert_return(() => invoke($17, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3762
+assert_return(() => invoke($17, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3763
+assert_return(() => invoke($17, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3764
+assert_return(() => invoke($17, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3765
+assert_return(() => invoke($17, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3766
+assert_return(() => invoke($17, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3767
+assert_return(() => invoke($17, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3768
+assert_return(() => invoke($17, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3769
+assert_return(() => invoke($17, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3770
+assert_return(() => invoke($17, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3771
+assert_return(() => invoke($17, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3772
+assert_return(() => invoke($17, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3773
+assert_return(() => invoke($17, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3774
+assert_return(() => invoke($17, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3775
+assert_return(() => invoke($17, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3776
+assert_return(() => invoke($17, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3777
+assert_return(() => invoke($17, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3778
+assert_return(() => invoke($17, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3779
+assert_return(() => invoke($17, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3780
+assert_return(() => invoke($17, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3781
+assert_return(() => invoke($17, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3782
+assert_return(() => invoke($17, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3783
+assert_return(() => invoke($17, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3784
+assert_return(() => invoke($17, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3785
+assert_return(() => invoke($17, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3786
+assert_return(() => invoke($17, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3787
+assert_return(() => invoke($17, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3788
+assert_return(() => invoke($17, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3789
+assert_return(() => invoke($17, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3790
+assert_return(() => invoke($17, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3791
+assert_return(() => invoke($17, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3792
+assert_return(() => invoke($17, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3793
+assert_return(() => invoke($17, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3794
+assert_return(() => invoke($17, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3795
+assert_return(() => invoke($17, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3796
+assert_return(() => invoke($17, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3797
+assert_return(() => invoke($17, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3798
+assert_return(() => invoke($17, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3799
+assert_return(() => invoke($17, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3800
+assert_return(() => invoke($17, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3801
+assert_return(() => invoke($17, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3802
+assert_return(() => invoke($17, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3803
+assert_return(() => invoke($17, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3804
+assert_return(() => invoke($17, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3805
+assert_return(() => invoke($17, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3806
+assert_return(() => invoke($17, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3807
+assert_return(() => invoke($17, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3808
+assert_return(() => invoke($17, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3809
+assert_return(() => invoke($17, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3810
+assert_return(() => invoke($17, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3811
+assert_return(() => invoke($17, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3812
+assert_return(() => invoke($17, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3813
+assert_return(() => invoke($17, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3814
+assert_return(() => invoke($17, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3815
+assert_return(() => invoke($17, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3816
+assert_return(() => invoke($17, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3817
+assert_return(() => invoke($17, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3818
+assert_return(() => invoke($17, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3819
+assert_return(() => invoke($17, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3820
+assert_return(() => invoke($17, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3821
+assert_return(() => invoke($17, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3822
+assert_return(() => invoke($17, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3823
+assert_return(() => invoke($17, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3824
+assert_return(() => invoke($17, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3825
+assert_return(() => invoke($17, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3826
+assert_return(() => invoke($17, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3827
+assert_return(() => invoke($17, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3828
+assert_return(() => invoke($17, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3829
+assert_return(() => invoke($17, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3830
+assert_return(() => invoke($17, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3831
+assert_return(() => invoke($17, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3832
+assert_return(() => invoke($17, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3833
+assert_return(() => invoke($17, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3834
+assert_return(() => invoke($17, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3835
+assert_return(() => invoke($17, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3836
+assert_return(() => invoke($17, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3837
+assert_return(() => invoke($17, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3838
+assert_return(() => invoke($17, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3839
+assert_return(() => invoke($17, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3840
+assert_return(() => invoke($17, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3841
+assert_return(() => invoke($17, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3842
+assert_return(() => invoke($17, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3843
+assert_return(() => invoke($17, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3844
+assert_return(() => invoke($17, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3845
+assert_return(() => invoke($17, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3846
+assert_return(() => invoke($17, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3847
+assert_return(() => invoke($17, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3848
+assert_return(() => invoke($17, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3849
+assert_return(() => invoke($17, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3850
+assert_return(() => invoke($17, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3851
+assert_return(() => invoke($17, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3852
+assert_return(() => invoke($17, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3853
+assert_return(() => invoke($17, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3854
+assert_return(() => invoke($17, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3855
+assert_return(() => invoke($17, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3856
+assert_return(() => invoke($17, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3857
+assert_return(() => invoke($17, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3858
+assert_return(() => invoke($17, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3859
+assert_return(() => invoke($17, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3860
+assert_return(() => invoke($17, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3861
+assert_return(() => invoke($17, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3862
+assert_return(() => invoke($17, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3863
+assert_return(() => invoke($17, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3864
+assert_return(() => invoke($17, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3865
+assert_return(() => invoke($17, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3866
+assert_return(() => invoke($17, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3867
+assert_return(() => invoke($17, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3868
+assert_return(() => invoke($17, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3869
+assert_return(() => invoke($17, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3870
+assert_return(() => invoke($17, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3871
+assert_return(() => invoke($17, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3872
+assert_return(() => invoke($17, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3873
+assert_return(() => invoke($17, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3874
+assert_return(() => invoke($17, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3875
+assert_return(() => invoke($17, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3876
+assert_return(() => invoke($17, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3877
+assert_return(() => invoke($17, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3878
+assert_return(() => invoke($17, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3879
+assert_return(() => invoke($17, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3880
+assert_return(() => invoke($17, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3881
+assert_return(() => invoke($17, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3882
+assert_return(() => invoke($17, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3883
+assert_return(() => invoke($17, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3884
+assert_return(() => invoke($17, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3885
+assert_return(() => invoke($17, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3886
+assert_return(() => invoke($17, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3887
+assert_return(() => invoke($17, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3888
+assert_return(() => invoke($17, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3889
+assert_return(() => invoke($17, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3890
+assert_return(() => invoke($17, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3891
+assert_return(() => invoke($17, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3892
+assert_return(() => invoke($17, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3893
+assert_return(() => invoke($17, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3894
+assert_return(() => invoke($17, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3895
+assert_return(() => invoke($17, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3896
+assert_return(() => invoke($17, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3897
+assert_return(() => invoke($17, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3898
+assert_return(() => invoke($17, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3899
+assert_return(() => invoke($17, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3900
+assert_return(() => invoke($17, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3901
+assert_return(() => invoke($17, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3902
+assert_return(() => invoke($17, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3903
+assert_return(() => invoke($17, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3904
+assert_return(() => invoke($17, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3905
+assert_return(() => invoke($17, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3906
+assert_return(() => invoke($17, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3907
+assert_return(() => invoke($17, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3908
+assert_return(() => invoke($17, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3909
+assert_return(() => invoke($17, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3910
+assert_return(() => invoke($17, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3911
+assert_return(() => invoke($17, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3912
+assert_return(() => invoke($17, `load8_u`, [61490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3913
+assert_return(() => invoke($17, `load8_u`, [61689]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3914
+assert_return(() => invoke($17, `load8_u`, [61888]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3915
+assert_return(() => invoke($17, `load8_u`, [62087]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3916
+assert_return(() => invoke($17, `load8_u`, [62286]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3917
+assert_return(() => invoke($17, `load8_u`, [62485]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3918
+assert_return(() => invoke($17, `load8_u`, [62684]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3919
+assert_return(() => invoke($17, `load8_u`, [62883]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3920
+assert_return(() => invoke($17, `load8_u`, [63082]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3921
+assert_return(() => invoke($17, `load8_u`, [63281]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3922
+assert_return(() => invoke($17, `load8_u`, [63480]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3923
+assert_return(() => invoke($17, `load8_u`, [63679]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3924
+assert_return(() => invoke($17, `load8_u`, [63878]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3925
+assert_return(() => invoke($17, `load8_u`, [64077]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3926
+assert_return(() => invoke($17, `load8_u`, [64276]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3927
+assert_return(() => invoke($17, `load8_u`, [64475]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3928
+assert_return(() => invoke($17, `load8_u`, [64674]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3929
+assert_return(() => invoke($17, `load8_u`, [64873]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3930
+assert_return(() => invoke($17, `load8_u`, [65072]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3931
+assert_return(() => invoke($17, `load8_u`, [65271]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3932
+assert_return(() => invoke($17, `load8_u`, [65470]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3933
+assert_return(() => invoke($17, `load8_u`, [65516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3934
+assert_return(() => invoke($17, `load8_u`, [65517]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:3935
+assert_return(() => invoke($17, `load8_u`, [65518]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:3936
+assert_return(() => invoke($17, `load8_u`, [65519]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:3937
+assert_return(() => invoke($17, `load8_u`, [65520]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:3938
+assert_return(() => invoke($17, `load8_u`, [65521]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:3939
+assert_return(() => invoke($17, `load8_u`, [65522]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:3940
+assert_return(() => invoke($17, `load8_u`, [65523]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:3941
+assert_return(() => invoke($17, `load8_u`, [65524]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:3942
+assert_return(() => invoke($17, `load8_u`, [65525]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:3943
+assert_return(() => invoke($17, `load8_u`, [65526]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:3944
+assert_return(() => invoke($17, `load8_u`, [65527]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:3945
+assert_return(() => invoke($17, `load8_u`, [65528]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:3946
+assert_return(() => invoke($17, `load8_u`, [65529]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:3947
+assert_return(() => invoke($17, `load8_u`, [65530]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:3948
+assert_return(() => invoke($17, `load8_u`, [65531]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:3949
+assert_return(() => invoke($17, `load8_u`, [65532]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:3950
+assert_return(() => invoke($17, `load8_u`, [65533]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:3951
+assert_return(() => invoke($17, `load8_u`, [65534]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:3952
+assert_return(() => invoke($17, `load8_u`, [65535]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:3954
+let $18 = instantiate(`(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 61440) "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f\\10\\11\\12\\13")
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (memory.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_copy.wast:3962
+assert_trap(() => invoke($18, `run`, [65516, 61440, -256]), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:3965
+assert_return(() => invoke($18, `load8_u`, [198]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3966
+assert_return(() => invoke($18, `load8_u`, [397]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3967
+assert_return(() => invoke($18, `load8_u`, [596]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3968
+assert_return(() => invoke($18, `load8_u`, [795]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3969
+assert_return(() => invoke($18, `load8_u`, [994]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3970
+assert_return(() => invoke($18, `load8_u`, [1193]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3971
+assert_return(() => invoke($18, `load8_u`, [1392]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3972
+assert_return(() => invoke($18, `load8_u`, [1591]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3973
+assert_return(() => invoke($18, `load8_u`, [1790]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3974
+assert_return(() => invoke($18, `load8_u`, [1989]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3975
+assert_return(() => invoke($18, `load8_u`, [2188]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3976
+assert_return(() => invoke($18, `load8_u`, [2387]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3977
+assert_return(() => invoke($18, `load8_u`, [2586]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3978
+assert_return(() => invoke($18, `load8_u`, [2785]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3979
+assert_return(() => invoke($18, `load8_u`, [2984]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3980
+assert_return(() => invoke($18, `load8_u`, [3183]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3981
+assert_return(() => invoke($18, `load8_u`, [3382]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3982
+assert_return(() => invoke($18, `load8_u`, [3581]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3983
+assert_return(() => invoke($18, `load8_u`, [3780]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3984
+assert_return(() => invoke($18, `load8_u`, [3979]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3985
+assert_return(() => invoke($18, `load8_u`, [4178]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3986
+assert_return(() => invoke($18, `load8_u`, [4377]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3987
+assert_return(() => invoke($18, `load8_u`, [4576]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3988
+assert_return(() => invoke($18, `load8_u`, [4775]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3989
+assert_return(() => invoke($18, `load8_u`, [4974]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3990
+assert_return(() => invoke($18, `load8_u`, [5173]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3991
+assert_return(() => invoke($18, `load8_u`, [5372]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3992
+assert_return(() => invoke($18, `load8_u`, [5571]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3993
+assert_return(() => invoke($18, `load8_u`, [5770]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3994
+assert_return(() => invoke($18, `load8_u`, [5969]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3995
+assert_return(() => invoke($18, `load8_u`, [6168]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3996
+assert_return(() => invoke($18, `load8_u`, [6367]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3997
+assert_return(() => invoke($18, `load8_u`, [6566]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3998
+assert_return(() => invoke($18, `load8_u`, [6765]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:3999
+assert_return(() => invoke($18, `load8_u`, [6964]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4000
+assert_return(() => invoke($18, `load8_u`, [7163]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4001
+assert_return(() => invoke($18, `load8_u`, [7362]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4002
+assert_return(() => invoke($18, `load8_u`, [7561]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4003
+assert_return(() => invoke($18, `load8_u`, [7760]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4004
+assert_return(() => invoke($18, `load8_u`, [7959]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4005
+assert_return(() => invoke($18, `load8_u`, [8158]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4006
+assert_return(() => invoke($18, `load8_u`, [8357]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4007
+assert_return(() => invoke($18, `load8_u`, [8556]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4008
+assert_return(() => invoke($18, `load8_u`, [8755]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4009
+assert_return(() => invoke($18, `load8_u`, [8954]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4010
+assert_return(() => invoke($18, `load8_u`, [9153]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4011
+assert_return(() => invoke($18, `load8_u`, [9352]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4012
+assert_return(() => invoke($18, `load8_u`, [9551]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4013
+assert_return(() => invoke($18, `load8_u`, [9750]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4014
+assert_return(() => invoke($18, `load8_u`, [9949]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4015
+assert_return(() => invoke($18, `load8_u`, [10148]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4016
+assert_return(() => invoke($18, `load8_u`, [10347]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4017
+assert_return(() => invoke($18, `load8_u`, [10546]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4018
+assert_return(() => invoke($18, `load8_u`, [10745]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4019
+assert_return(() => invoke($18, `load8_u`, [10944]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4020
+assert_return(() => invoke($18, `load8_u`, [11143]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4021
+assert_return(() => invoke($18, `load8_u`, [11342]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4022
+assert_return(() => invoke($18, `load8_u`, [11541]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4023
+assert_return(() => invoke($18, `load8_u`, [11740]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4024
+assert_return(() => invoke($18, `load8_u`, [11939]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4025
+assert_return(() => invoke($18, `load8_u`, [12138]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4026
+assert_return(() => invoke($18, `load8_u`, [12337]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4027
+assert_return(() => invoke($18, `load8_u`, [12536]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4028
+assert_return(() => invoke($18, `load8_u`, [12735]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4029
+assert_return(() => invoke($18, `load8_u`, [12934]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4030
+assert_return(() => invoke($18, `load8_u`, [13133]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4031
+assert_return(() => invoke($18, `load8_u`, [13332]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4032
+assert_return(() => invoke($18, `load8_u`, [13531]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4033
+assert_return(() => invoke($18, `load8_u`, [13730]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4034
+assert_return(() => invoke($18, `load8_u`, [13929]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4035
+assert_return(() => invoke($18, `load8_u`, [14128]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4036
+assert_return(() => invoke($18, `load8_u`, [14327]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4037
+assert_return(() => invoke($18, `load8_u`, [14526]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4038
+assert_return(() => invoke($18, `load8_u`, [14725]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4039
+assert_return(() => invoke($18, `load8_u`, [14924]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4040
+assert_return(() => invoke($18, `load8_u`, [15123]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4041
+assert_return(() => invoke($18, `load8_u`, [15322]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4042
+assert_return(() => invoke($18, `load8_u`, [15521]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4043
+assert_return(() => invoke($18, `load8_u`, [15720]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4044
+assert_return(() => invoke($18, `load8_u`, [15919]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4045
+assert_return(() => invoke($18, `load8_u`, [16118]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4046
+assert_return(() => invoke($18, `load8_u`, [16317]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4047
+assert_return(() => invoke($18, `load8_u`, [16516]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4048
+assert_return(() => invoke($18, `load8_u`, [16715]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4049
+assert_return(() => invoke($18, `load8_u`, [16914]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4050
+assert_return(() => invoke($18, `load8_u`, [17113]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4051
+assert_return(() => invoke($18, `load8_u`, [17312]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4052
+assert_return(() => invoke($18, `load8_u`, [17511]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4053
+assert_return(() => invoke($18, `load8_u`, [17710]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4054
+assert_return(() => invoke($18, `load8_u`, [17909]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4055
+assert_return(() => invoke($18, `load8_u`, [18108]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4056
+assert_return(() => invoke($18, `load8_u`, [18307]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4057
+assert_return(() => invoke($18, `load8_u`, [18506]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4058
+assert_return(() => invoke($18, `load8_u`, [18705]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4059
+assert_return(() => invoke($18, `load8_u`, [18904]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4060
+assert_return(() => invoke($18, `load8_u`, [19103]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4061
+assert_return(() => invoke($18, `load8_u`, [19302]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4062
+assert_return(() => invoke($18, `load8_u`, [19501]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4063
+assert_return(() => invoke($18, `load8_u`, [19700]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4064
+assert_return(() => invoke($18, `load8_u`, [19899]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4065
+assert_return(() => invoke($18, `load8_u`, [20098]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4066
+assert_return(() => invoke($18, `load8_u`, [20297]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4067
+assert_return(() => invoke($18, `load8_u`, [20496]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4068
+assert_return(() => invoke($18, `load8_u`, [20695]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4069
+assert_return(() => invoke($18, `load8_u`, [20894]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4070
+assert_return(() => invoke($18, `load8_u`, [21093]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4071
+assert_return(() => invoke($18, `load8_u`, [21292]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4072
+assert_return(() => invoke($18, `load8_u`, [21491]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4073
+assert_return(() => invoke($18, `load8_u`, [21690]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4074
+assert_return(() => invoke($18, `load8_u`, [21889]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4075
+assert_return(() => invoke($18, `load8_u`, [22088]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4076
+assert_return(() => invoke($18, `load8_u`, [22287]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4077
+assert_return(() => invoke($18, `load8_u`, [22486]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4078
+assert_return(() => invoke($18, `load8_u`, [22685]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4079
+assert_return(() => invoke($18, `load8_u`, [22884]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4080
+assert_return(() => invoke($18, `load8_u`, [23083]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4081
+assert_return(() => invoke($18, `load8_u`, [23282]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4082
+assert_return(() => invoke($18, `load8_u`, [23481]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4083
+assert_return(() => invoke($18, `load8_u`, [23680]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4084
+assert_return(() => invoke($18, `load8_u`, [23879]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4085
+assert_return(() => invoke($18, `load8_u`, [24078]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4086
+assert_return(() => invoke($18, `load8_u`, [24277]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4087
+assert_return(() => invoke($18, `load8_u`, [24476]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4088
+assert_return(() => invoke($18, `load8_u`, [24675]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4089
+assert_return(() => invoke($18, `load8_u`, [24874]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4090
+assert_return(() => invoke($18, `load8_u`, [25073]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4091
+assert_return(() => invoke($18, `load8_u`, [25272]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4092
+assert_return(() => invoke($18, `load8_u`, [25471]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4093
+assert_return(() => invoke($18, `load8_u`, [25670]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4094
+assert_return(() => invoke($18, `load8_u`, [25869]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4095
+assert_return(() => invoke($18, `load8_u`, [26068]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4096
+assert_return(() => invoke($18, `load8_u`, [26267]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4097
+assert_return(() => invoke($18, `load8_u`, [26466]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4098
+assert_return(() => invoke($18, `load8_u`, [26665]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4099
+assert_return(() => invoke($18, `load8_u`, [26864]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4100
+assert_return(() => invoke($18, `load8_u`, [27063]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4101
+assert_return(() => invoke($18, `load8_u`, [27262]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4102
+assert_return(() => invoke($18, `load8_u`, [27461]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4103
+assert_return(() => invoke($18, `load8_u`, [27660]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4104
+assert_return(() => invoke($18, `load8_u`, [27859]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4105
+assert_return(() => invoke($18, `load8_u`, [28058]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4106
+assert_return(() => invoke($18, `load8_u`, [28257]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4107
+assert_return(() => invoke($18, `load8_u`, [28456]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4108
+assert_return(() => invoke($18, `load8_u`, [28655]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4109
+assert_return(() => invoke($18, `load8_u`, [28854]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4110
+assert_return(() => invoke($18, `load8_u`, [29053]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4111
+assert_return(() => invoke($18, `load8_u`, [29252]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4112
+assert_return(() => invoke($18, `load8_u`, [29451]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4113
+assert_return(() => invoke($18, `load8_u`, [29650]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4114
+assert_return(() => invoke($18, `load8_u`, [29849]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4115
+assert_return(() => invoke($18, `load8_u`, [30048]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4116
+assert_return(() => invoke($18, `load8_u`, [30247]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4117
+assert_return(() => invoke($18, `load8_u`, [30446]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4118
+assert_return(() => invoke($18, `load8_u`, [30645]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4119
+assert_return(() => invoke($18, `load8_u`, [30844]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4120
+assert_return(() => invoke($18, `load8_u`, [31043]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4121
+assert_return(() => invoke($18, `load8_u`, [31242]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4122
+assert_return(() => invoke($18, `load8_u`, [31441]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4123
+assert_return(() => invoke($18, `load8_u`, [31640]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4124
+assert_return(() => invoke($18, `load8_u`, [31839]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4125
+assert_return(() => invoke($18, `load8_u`, [32038]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4126
+assert_return(() => invoke($18, `load8_u`, [32237]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4127
+assert_return(() => invoke($18, `load8_u`, [32436]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4128
+assert_return(() => invoke($18, `load8_u`, [32635]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4129
+assert_return(() => invoke($18, `load8_u`, [32834]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4130
+assert_return(() => invoke($18, `load8_u`, [33033]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4131
+assert_return(() => invoke($18, `load8_u`, [33232]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4132
+assert_return(() => invoke($18, `load8_u`, [33431]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4133
+assert_return(() => invoke($18, `load8_u`, [33630]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4134
+assert_return(() => invoke($18, `load8_u`, [33829]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4135
+assert_return(() => invoke($18, `load8_u`, [34028]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4136
+assert_return(() => invoke($18, `load8_u`, [34227]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4137
+assert_return(() => invoke($18, `load8_u`, [34426]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4138
+assert_return(() => invoke($18, `load8_u`, [34625]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4139
+assert_return(() => invoke($18, `load8_u`, [34824]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4140
+assert_return(() => invoke($18, `load8_u`, [35023]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4141
+assert_return(() => invoke($18, `load8_u`, [35222]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4142
+assert_return(() => invoke($18, `load8_u`, [35421]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4143
+assert_return(() => invoke($18, `load8_u`, [35620]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4144
+assert_return(() => invoke($18, `load8_u`, [35819]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4145
+assert_return(() => invoke($18, `load8_u`, [36018]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4146
+assert_return(() => invoke($18, `load8_u`, [36217]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4147
+assert_return(() => invoke($18, `load8_u`, [36416]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4148
+assert_return(() => invoke($18, `load8_u`, [36615]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4149
+assert_return(() => invoke($18, `load8_u`, [36814]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4150
+assert_return(() => invoke($18, `load8_u`, [37013]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4151
+assert_return(() => invoke($18, `load8_u`, [37212]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4152
+assert_return(() => invoke($18, `load8_u`, [37411]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4153
+assert_return(() => invoke($18, `load8_u`, [37610]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4154
+assert_return(() => invoke($18, `load8_u`, [37809]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4155
+assert_return(() => invoke($18, `load8_u`, [38008]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4156
+assert_return(() => invoke($18, `load8_u`, [38207]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4157
+assert_return(() => invoke($18, `load8_u`, [38406]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4158
+assert_return(() => invoke($18, `load8_u`, [38605]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4159
+assert_return(() => invoke($18, `load8_u`, [38804]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4160
+assert_return(() => invoke($18, `load8_u`, [39003]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4161
+assert_return(() => invoke($18, `load8_u`, [39202]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4162
+assert_return(() => invoke($18, `load8_u`, [39401]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4163
+assert_return(() => invoke($18, `load8_u`, [39600]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4164
+assert_return(() => invoke($18, `load8_u`, [39799]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4165
+assert_return(() => invoke($18, `load8_u`, [39998]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4166
+assert_return(() => invoke($18, `load8_u`, [40197]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4167
+assert_return(() => invoke($18, `load8_u`, [40396]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4168
+assert_return(() => invoke($18, `load8_u`, [40595]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4169
+assert_return(() => invoke($18, `load8_u`, [40794]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4170
+assert_return(() => invoke($18, `load8_u`, [40993]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4171
+assert_return(() => invoke($18, `load8_u`, [41192]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4172
+assert_return(() => invoke($18, `load8_u`, [41391]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4173
+assert_return(() => invoke($18, `load8_u`, [41590]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4174
+assert_return(() => invoke($18, `load8_u`, [41789]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4175
+assert_return(() => invoke($18, `load8_u`, [41988]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4176
+assert_return(() => invoke($18, `load8_u`, [42187]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4177
+assert_return(() => invoke($18, `load8_u`, [42386]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4178
+assert_return(() => invoke($18, `load8_u`, [42585]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4179
+assert_return(() => invoke($18, `load8_u`, [42784]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4180
+assert_return(() => invoke($18, `load8_u`, [42983]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4181
+assert_return(() => invoke($18, `load8_u`, [43182]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4182
+assert_return(() => invoke($18, `load8_u`, [43381]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4183
+assert_return(() => invoke($18, `load8_u`, [43580]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4184
+assert_return(() => invoke($18, `load8_u`, [43779]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4185
+assert_return(() => invoke($18, `load8_u`, [43978]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4186
+assert_return(() => invoke($18, `load8_u`, [44177]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4187
+assert_return(() => invoke($18, `load8_u`, [44376]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4188
+assert_return(() => invoke($18, `load8_u`, [44575]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4189
+assert_return(() => invoke($18, `load8_u`, [44774]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4190
+assert_return(() => invoke($18, `load8_u`, [44973]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4191
+assert_return(() => invoke($18, `load8_u`, [45172]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4192
+assert_return(() => invoke($18, `load8_u`, [45371]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4193
+assert_return(() => invoke($18, `load8_u`, [45570]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4194
+assert_return(() => invoke($18, `load8_u`, [45769]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4195
+assert_return(() => invoke($18, `load8_u`, [45968]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4196
+assert_return(() => invoke($18, `load8_u`, [46167]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4197
+assert_return(() => invoke($18, `load8_u`, [46366]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4198
+assert_return(() => invoke($18, `load8_u`, [46565]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4199
+assert_return(() => invoke($18, `load8_u`, [46764]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4200
+assert_return(() => invoke($18, `load8_u`, [46963]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4201
+assert_return(() => invoke($18, `load8_u`, [47162]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4202
+assert_return(() => invoke($18, `load8_u`, [47361]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4203
+assert_return(() => invoke($18, `load8_u`, [47560]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4204
+assert_return(() => invoke($18, `load8_u`, [47759]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4205
+assert_return(() => invoke($18, `load8_u`, [47958]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4206
+assert_return(() => invoke($18, `load8_u`, [48157]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4207
+assert_return(() => invoke($18, `load8_u`, [48356]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4208
+assert_return(() => invoke($18, `load8_u`, [48555]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4209
+assert_return(() => invoke($18, `load8_u`, [48754]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4210
+assert_return(() => invoke($18, `load8_u`, [48953]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4211
+assert_return(() => invoke($18, `load8_u`, [49152]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4212
+assert_return(() => invoke($18, `load8_u`, [49351]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4213
+assert_return(() => invoke($18, `load8_u`, [49550]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4214
+assert_return(() => invoke($18, `load8_u`, [49749]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4215
+assert_return(() => invoke($18, `load8_u`, [49948]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4216
+assert_return(() => invoke($18, `load8_u`, [50147]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4217
+assert_return(() => invoke($18, `load8_u`, [50346]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4218
+assert_return(() => invoke($18, `load8_u`, [50545]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4219
+assert_return(() => invoke($18, `load8_u`, [50744]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4220
+assert_return(() => invoke($18, `load8_u`, [50943]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4221
+assert_return(() => invoke($18, `load8_u`, [51142]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4222
+assert_return(() => invoke($18, `load8_u`, [51341]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4223
+assert_return(() => invoke($18, `load8_u`, [51540]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4224
+assert_return(() => invoke($18, `load8_u`, [51739]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4225
+assert_return(() => invoke($18, `load8_u`, [51938]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4226
+assert_return(() => invoke($18, `load8_u`, [52137]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4227
+assert_return(() => invoke($18, `load8_u`, [52336]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4228
+assert_return(() => invoke($18, `load8_u`, [52535]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4229
+assert_return(() => invoke($18, `load8_u`, [52734]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4230
+assert_return(() => invoke($18, `load8_u`, [52933]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4231
+assert_return(() => invoke($18, `load8_u`, [53132]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4232
+assert_return(() => invoke($18, `load8_u`, [53331]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4233
+assert_return(() => invoke($18, `load8_u`, [53530]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4234
+assert_return(() => invoke($18, `load8_u`, [53729]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4235
+assert_return(() => invoke($18, `load8_u`, [53928]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4236
+assert_return(() => invoke($18, `load8_u`, [54127]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4237
+assert_return(() => invoke($18, `load8_u`, [54326]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4238
+assert_return(() => invoke($18, `load8_u`, [54525]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4239
+assert_return(() => invoke($18, `load8_u`, [54724]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4240
+assert_return(() => invoke($18, `load8_u`, [54923]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4241
+assert_return(() => invoke($18, `load8_u`, [55122]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4242
+assert_return(() => invoke($18, `load8_u`, [55321]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4243
+assert_return(() => invoke($18, `load8_u`, [55520]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4244
+assert_return(() => invoke($18, `load8_u`, [55719]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4245
+assert_return(() => invoke($18, `load8_u`, [55918]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4246
+assert_return(() => invoke($18, `load8_u`, [56117]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4247
+assert_return(() => invoke($18, `load8_u`, [56316]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4248
+assert_return(() => invoke($18, `load8_u`, [56515]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4249
+assert_return(() => invoke($18, `load8_u`, [56714]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4250
+assert_return(() => invoke($18, `load8_u`, [56913]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4251
+assert_return(() => invoke($18, `load8_u`, [57112]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4252
+assert_return(() => invoke($18, `load8_u`, [57311]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4253
+assert_return(() => invoke($18, `load8_u`, [57510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4254
+assert_return(() => invoke($18, `load8_u`, [57709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4255
+assert_return(() => invoke($18, `load8_u`, [57908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4256
+assert_return(() => invoke($18, `load8_u`, [58107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4257
+assert_return(() => invoke($18, `load8_u`, [58306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4258
+assert_return(() => invoke($18, `load8_u`, [58505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4259
+assert_return(() => invoke($18, `load8_u`, [58704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4260
+assert_return(() => invoke($18, `load8_u`, [58903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4261
+assert_return(() => invoke($18, `load8_u`, [59102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4262
+assert_return(() => invoke($18, `load8_u`, [59301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4263
+assert_return(() => invoke($18, `load8_u`, [59500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4264
+assert_return(() => invoke($18, `load8_u`, [59699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4265
+assert_return(() => invoke($18, `load8_u`, [59898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4266
+assert_return(() => invoke($18, `load8_u`, [60097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4267
+assert_return(() => invoke($18, `load8_u`, [60296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4268
+assert_return(() => invoke($18, `load8_u`, [60495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4269
+assert_return(() => invoke($18, `load8_u`, [60694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4270
+assert_return(() => invoke($18, `load8_u`, [60893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4271
+assert_return(() => invoke($18, `load8_u`, [61092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4272
+assert_return(() => invoke($18, `load8_u`, [61291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4273
+assert_return(() => invoke($18, `load8_u`, [61440]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4274
+assert_return(() => invoke($18, `load8_u`, [61441]), [value("i32", 1)]);
+
+// ./test/core/memory_copy.wast:4275
+assert_return(() => invoke($18, `load8_u`, [61442]), [value("i32", 2)]);
+
+// ./test/core/memory_copy.wast:4276
+assert_return(() => invoke($18, `load8_u`, [61443]), [value("i32", 3)]);
+
+// ./test/core/memory_copy.wast:4277
+assert_return(() => invoke($18, `load8_u`, [61444]), [value("i32", 4)]);
+
+// ./test/core/memory_copy.wast:4278
+assert_return(() => invoke($18, `load8_u`, [61445]), [value("i32", 5)]);
+
+// ./test/core/memory_copy.wast:4279
+assert_return(() => invoke($18, `load8_u`, [61446]), [value("i32", 6)]);
+
+// ./test/core/memory_copy.wast:4280
+assert_return(() => invoke($18, `load8_u`, [61447]), [value("i32", 7)]);
+
+// ./test/core/memory_copy.wast:4281
+assert_return(() => invoke($18, `load8_u`, [61448]), [value("i32", 8)]);
+
+// ./test/core/memory_copy.wast:4282
+assert_return(() => invoke($18, `load8_u`, [61449]), [value("i32", 9)]);
+
+// ./test/core/memory_copy.wast:4283
+assert_return(() => invoke($18, `load8_u`, [61450]), [value("i32", 10)]);
+
+// ./test/core/memory_copy.wast:4284
+assert_return(() => invoke($18, `load8_u`, [61451]), [value("i32", 11)]);
+
+// ./test/core/memory_copy.wast:4285
+assert_return(() => invoke($18, `load8_u`, [61452]), [value("i32", 12)]);
+
+// ./test/core/memory_copy.wast:4286
+assert_return(() => invoke($18, `load8_u`, [61453]), [value("i32", 13)]);
+
+// ./test/core/memory_copy.wast:4287
+assert_return(() => invoke($18, `load8_u`, [61454]), [value("i32", 14)]);
+
+// ./test/core/memory_copy.wast:4288
+assert_return(() => invoke($18, `load8_u`, [61455]), [value("i32", 15)]);
+
+// ./test/core/memory_copy.wast:4289
+assert_return(() => invoke($18, `load8_u`, [61456]), [value("i32", 16)]);
+
+// ./test/core/memory_copy.wast:4290
+assert_return(() => invoke($18, `load8_u`, [61457]), [value("i32", 17)]);
+
+// ./test/core/memory_copy.wast:4291
+assert_return(() => invoke($18, `load8_u`, [61458]), [value("i32", 18)]);
+
+// ./test/core/memory_copy.wast:4292
+assert_return(() => invoke($18, `load8_u`, [61459]), [value("i32", 19)]);
+
+// ./test/core/memory_copy.wast:4293
+assert_return(() => invoke($18, `load8_u`, [61510]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4294
+assert_return(() => invoke($18, `load8_u`, [61709]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4295
+assert_return(() => invoke($18, `load8_u`, [61908]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4296
+assert_return(() => invoke($18, `load8_u`, [62107]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4297
+assert_return(() => invoke($18, `load8_u`, [62306]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4298
+assert_return(() => invoke($18, `load8_u`, [62505]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4299
+assert_return(() => invoke($18, `load8_u`, [62704]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4300
+assert_return(() => invoke($18, `load8_u`, [62903]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4301
+assert_return(() => invoke($18, `load8_u`, [63102]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4302
+assert_return(() => invoke($18, `load8_u`, [63301]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4303
+assert_return(() => invoke($18, `load8_u`, [63500]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4304
+assert_return(() => invoke($18, `load8_u`, [63699]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4305
+assert_return(() => invoke($18, `load8_u`, [63898]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4306
+assert_return(() => invoke($18, `load8_u`, [64097]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4307
+assert_return(() => invoke($18, `load8_u`, [64296]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4308
+assert_return(() => invoke($18, `load8_u`, [64495]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4309
+assert_return(() => invoke($18, `load8_u`, [64694]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4310
+assert_return(() => invoke($18, `load8_u`, [64893]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4311
+assert_return(() => invoke($18, `load8_u`, [65092]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4312
+assert_return(() => invoke($18, `load8_u`, [65291]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4313
+assert_return(() => invoke($18, `load8_u`, [65490]), [value("i32", 0)]);
+
+// ./test/core/memory_copy.wast:4315
+assert_invalid(
+  () => instantiate(`(module
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i32.const 30))))`),
+  `unknown memory 0`,
+);
+
+// ./test/core/memory_copy.wast:4321
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4328
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4335
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4342
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4349
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4356
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4363
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4370
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4377
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4384
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4391
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4398
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4405
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4412
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4419
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4426
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4433
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4440
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4447
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4454
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4461
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4468
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4475
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4482
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4489
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4496
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4503
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4510
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4517
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4524
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4531
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4538
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4545
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4552
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4559
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4566
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4573
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4580
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4587
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4594
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4601
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4608
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4615
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4622
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4629
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4636
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4643
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4650
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4657
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4664
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4671
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4678
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4685
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4692
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4699
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4706
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4713
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4720
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4727
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4734
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4741
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4748
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4755
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_copy.wast:4763
+let $19 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 9) (i32.const 10) (i32.const 5)))
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+)`);
+
+// ./test/core/memory_copy.wast:4780
+invoke($19, `test`, []);
+
+// ./test/core/memory_copy.wast:4782
+assert_return(() => invoke($19, `checkRange`, [0, 9, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4784
+assert_return(() => invoke($19, `checkRange`, [9, 20, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4786
+assert_return(() => invoke($19, `checkRange`, [20, 65536, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4789
+let $20 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 16) (i32.const 15) (i32.const 5)))
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+)`);
+
+// ./test/core/memory_copy.wast:4806
+invoke($20, `test`, []);
+
+// ./test/core/memory_copy.wast:4808
+assert_return(() => invoke($20, `checkRange`, [0, 10, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4810
+assert_return(() => invoke($20, `checkRange`, [10, 21, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4812
+assert_return(() => invoke($20, `checkRange`, [21, 65536, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4815
+let $21 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257))))`);
+
+// ./test/core/memory_copy.wast:4819
+assert_trap(() => invoke($21, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4821
+let $22 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257))))`);
+
+// ./test/core/memory_copy.wast:4825
+assert_trap(() => invoke($22, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4827
+let $23 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257))))`);
+
+// ./test/core/memory_copy.wast:4831
+assert_trap(() => invoke($23, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4833
+let $24 = instantiate(`(module
+ (memory 1 1)
+ (func (export "test")
+   (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257))))`);
+
+// ./test/core/memory_copy.wast:4837
+assert_trap(() => invoke($24, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4839
+let $25 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000))
+    (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000))
+    (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0)))
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+)`);
+
+// ./test/core/memory_copy.wast:4857
+invoke($25, `test`, []);
+
+// ./test/core/memory_copy.wast:4859
+assert_return(() => invoke($25, `checkRange`, [0, 32768, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4861
+assert_return(() => invoke($25, `checkRange`, [32768, 65536, 170]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:4863
+let $26 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0))))`);
+
+// ./test/core/memory_copy.wast:4867
+invoke($26, `test`, []);
+
+// ./test/core/memory_copy.wast:4869
+let $27 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0))))`);
+
+// ./test/core/memory_copy.wast:4873
+assert_trap(() => invoke($27, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4875
+let $28 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0))))`);
+
+// ./test/core/memory_copy.wast:4879
+invoke($28, `test`, []);
+
+// ./test/core/memory_copy.wast:4881
+let $29 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0))))`);
+
+// ./test/core/memory_copy.wast:4885
+assert_trap(() => invoke($29, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4887
+let $30 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x10000) (i32.const 0))))`);
+
+// ./test/core/memory_copy.wast:4891
+invoke($30, `test`, []);
+
+// ./test/core/memory_copy.wast:4893
+let $31 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0))))`);
+
+// ./test/core/memory_copy.wast:4897
+assert_trap(() => invoke($31, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_copy.wast:4899
+let $32 = instantiate(`(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344))
+    (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055))
+    (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988))
+    (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322))
+    (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994))
+    (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036))
+    (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372))
+    (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835))
+    (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393))
+    (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758))
+    (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098))
+    (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741))
+    (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823))
+    (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280))
+    (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466))
+    (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158))
+    (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544))
+    (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669))
+    (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651))
+    (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570))
+    (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691))
+    (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646))
+    (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858))
+    (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657))
+    (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981))
+    (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807))
+    (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487))
+    (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530))
+    (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943))
+    (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381))
+    (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089))
+    (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658))
+    (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702))
+    (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092))
+    (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410))
+    (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204))
+    (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394))
+    (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250))
+    (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097))
+    (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264))
+    (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299))
+    (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796))
+    (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070))
+    (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763))
+    (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312))
+    (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192))
+    (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596))
+    (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501))
+    (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686))
+    (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385))
+    (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903))
+    (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390))
+    (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441))
+    (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162))
+    (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135))
+    (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519))
+    (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280))
+    (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678))
+    (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168))
+    (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441))
+    (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663))
+    (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671))
+    (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721))
+    (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84))
+    (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029))
+    (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29))
+    (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034))
+    (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043))
+    (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324))
+    (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091))
+    (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997))
+    (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259))
+    (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189))
+    (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968))
+    (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455))
+    (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177))
+    (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568))
+    (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642))
+    (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284))
+    (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223))
+    (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171))
+    (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322))
+    (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648))
+    (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045))
+    (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097))
+    (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796))
+    (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010))
+    (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0))
+    (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069))
+    (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896))
+    (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192))
+    (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195))
+    (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24))
+    (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577))
+    (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089))
+    (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436))
+    (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765))
+    (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830))
+    (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938))
+    (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750))
+    (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098))
+    (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230))
+    (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300))
+    (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639))
+    (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097))
+    (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197))
+    (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100))
+    (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717))
+    (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119))
+    (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658))
+    (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269))
+    (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833))
+    (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300))
+    (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281))
+    (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572))
+    (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328))
+    (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670))
+    (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33))
+    (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427))
+    (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434))
+    (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834))
+    (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317))
+    (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201))
+    (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452))
+    (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346))
+    (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430))
+    (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300))
+    (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153))
+    (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281))
+    (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943))
+    (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887))
+    (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738))
+    (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122))
+    (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755))
+    (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702))
+    (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830))
+    (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064))
+    (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631))
+    (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113))
+    (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975))
+    (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336))
+    (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872))
+    (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197))
+    (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958))
+    (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186))
+    (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037))
+    (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650))
+    (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986))
+    (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955))
+    (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368))
+    (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356))
+    (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382))
+    (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900))
+    (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807))
+    (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323))
+    (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670))
+    (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341))
+    (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644))
+    (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496))
+    (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784))
+    (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350))
+    (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475))
+    (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467))
+    (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895))
+    (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751))
+    (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127))
+    (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063))
+    (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766))
+    (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520))
+    (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014))
+    (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011))
+    (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034))
+    (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320))
+    (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308))
+    (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155))
+    (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722))
+    (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370))
+    (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926))
+    (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607))
+    (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045))
+    (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596))
+    (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168))
+    (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137))
+    (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649))
+    (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52))
+    (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441))
+    (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445))
+    (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785))
+    (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406))
+    (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381))
+    (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136))
+    (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045))
+    (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389))
+    (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877))
+    (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447))
+    (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854))
+    (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377))
+    (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594))
+    (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987))
+    (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406))
+  )
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+)`);
+
+// ./test/core/memory_copy.wast:5115
+invoke($32, `test`, []);
+
+// ./test/core/memory_copy.wast:5117
+assert_return(() => invoke($32, `checkRange`, [0, 124, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5119
+assert_return(() => invoke($32, `checkRange`, [124, 1517, 9]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5121
+assert_return(() => invoke($32, `checkRange`, [1517, 2132, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5123
+assert_return(() => invoke($32, `checkRange`, [2132, 2827, 10]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5125
+assert_return(() => invoke($32, `checkRange`, [2827, 2921, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5127
+assert_return(() => invoke($32, `checkRange`, [2921, 3538, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5129
+assert_return(() => invoke($32, `checkRange`, [3538, 3786, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5131
+assert_return(() => invoke($32, `checkRange`, [3786, 4042, 97]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5133
+assert_return(() => invoke($32, `checkRange`, [4042, 4651, 99]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5135
+assert_return(() => invoke($32, `checkRange`, [4651, 5057, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5137
+assert_return(() => invoke($32, `checkRange`, [5057, 5109, 99]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5139
+assert_return(() => invoke($32, `checkRange`, [5109, 5291, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5141
+assert_return(() => invoke($32, `checkRange`, [5291, 5524, 72]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5143
+assert_return(() => invoke($32, `checkRange`, [5524, 5691, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5145
+assert_return(() => invoke($32, `checkRange`, [5691, 6552, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5147
+assert_return(() => invoke($32, `checkRange`, [6552, 7133, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5149
+assert_return(() => invoke($32, `checkRange`, [7133, 7665, 99]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5151
+assert_return(() => invoke($32, `checkRange`, [7665, 8314, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5153
+assert_return(() => invoke($32, `checkRange`, [8314, 8360, 62]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5155
+assert_return(() => invoke($32, `checkRange`, [8360, 8793, 86]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5157
+assert_return(() => invoke($32, `checkRange`, [8793, 8979, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5159
+assert_return(() => invoke($32, `checkRange`, [8979, 9373, 79]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5161
+assert_return(() => invoke($32, `checkRange`, [9373, 9518, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5163
+assert_return(() => invoke($32, `checkRange`, [9518, 9934, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5165
+assert_return(() => invoke($32, `checkRange`, [9934, 10087, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5167
+assert_return(() => invoke($32, `checkRange`, [10087, 10206, 5]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5169
+assert_return(() => invoke($32, `checkRange`, [10206, 10230, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5171
+assert_return(() => invoke($32, `checkRange`, [10230, 10249, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5173
+assert_return(() => invoke($32, `checkRange`, [10249, 11148, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5175
+assert_return(() => invoke($32, `checkRange`, [11148, 11356, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5177
+assert_return(() => invoke($32, `checkRange`, [11356, 11380, 93]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5179
+assert_return(() => invoke($32, `checkRange`, [11380, 11939, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5181
+assert_return(() => invoke($32, `checkRange`, [11939, 12159, 68]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5183
+assert_return(() => invoke($32, `checkRange`, [12159, 12575, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5185
+assert_return(() => invoke($32, `checkRange`, [12575, 12969, 79]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5187
+assert_return(() => invoke($32, `checkRange`, [12969, 13114, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5189
+assert_return(() => invoke($32, `checkRange`, [13114, 14133, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5191
+assert_return(() => invoke($32, `checkRange`, [14133, 14404, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5193
+assert_return(() => invoke($32, `checkRange`, [14404, 14428, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5195
+assert_return(() => invoke($32, `checkRange`, [14428, 14458, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5197
+assert_return(() => invoke($32, `checkRange`, [14458, 14580, 32]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5199
+assert_return(() => invoke($32, `checkRange`, [14580, 14777, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5201
+assert_return(() => invoke($32, `checkRange`, [14777, 15124, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5203
+assert_return(() => invoke($32, `checkRange`, [15124, 15126, 36]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5205
+assert_return(() => invoke($32, `checkRange`, [15126, 15192, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5207
+assert_return(() => invoke($32, `checkRange`, [15192, 15871, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5209
+assert_return(() => invoke($32, `checkRange`, [15871, 15998, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5211
+assert_return(() => invoke($32, `checkRange`, [15998, 17017, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5213
+assert_return(() => invoke($32, `checkRange`, [17017, 17288, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5215
+assert_return(() => invoke($32, `checkRange`, [17288, 17312, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5217
+assert_return(() => invoke($32, `checkRange`, [17312, 17342, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5219
+assert_return(() => invoke($32, `checkRange`, [17342, 17464, 32]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5221
+assert_return(() => invoke($32, `checkRange`, [17464, 17661, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5223
+assert_return(() => invoke($32, `checkRange`, [17661, 17727, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5225
+assert_return(() => invoke($32, `checkRange`, [17727, 17733, 5]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5227
+assert_return(() => invoke($32, `checkRange`, [17733, 17893, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5229
+assert_return(() => invoke($32, `checkRange`, [17893, 18553, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5231
+assert_return(() => invoke($32, `checkRange`, [18553, 18744, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5233
+assert_return(() => invoke($32, `checkRange`, [18744, 18801, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5235
+assert_return(() => invoke($32, `checkRange`, [18801, 18825, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5237
+assert_return(() => invoke($32, `checkRange`, [18825, 18876, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5239
+assert_return(() => invoke($32, `checkRange`, [18876, 18885, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5241
+assert_return(() => invoke($32, `checkRange`, [18885, 18904, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5243
+assert_return(() => invoke($32, `checkRange`, [18904, 19567, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5245
+assert_return(() => invoke($32, `checkRange`, [19567, 20403, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5247
+assert_return(() => invoke($32, `checkRange`, [20403, 21274, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5249
+assert_return(() => invoke($32, `checkRange`, [21274, 21364, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5251
+assert_return(() => invoke($32, `checkRange`, [21364, 21468, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5253
+assert_return(() => invoke($32, `checkRange`, [21468, 21492, 93]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5255
+assert_return(() => invoke($32, `checkRange`, [21492, 22051, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5257
+assert_return(() => invoke($32, `checkRange`, [22051, 22480, 68]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5259
+assert_return(() => invoke($32, `checkRange`, [22480, 22685, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5261
+assert_return(() => invoke($32, `checkRange`, [22685, 22694, 68]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5263
+assert_return(() => invoke($32, `checkRange`, [22694, 22821, 10]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5265
+assert_return(() => invoke($32, `checkRange`, [22821, 22869, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5267
+assert_return(() => invoke($32, `checkRange`, [22869, 24107, 97]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5269
+assert_return(() => invoke($32, `checkRange`, [24107, 24111, 37]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5271
+assert_return(() => invoke($32, `checkRange`, [24111, 24236, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5273
+assert_return(() => invoke($32, `checkRange`, [24236, 24348, 72]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5275
+assert_return(() => invoke($32, `checkRange`, [24348, 24515, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5277
+assert_return(() => invoke($32, `checkRange`, [24515, 24900, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5279
+assert_return(() => invoke($32, `checkRange`, [24900, 25136, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5281
+assert_return(() => invoke($32, `checkRange`, [25136, 25182, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5283
+assert_return(() => invoke($32, `checkRange`, [25182, 25426, 68]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5285
+assert_return(() => invoke($32, `checkRange`, [25426, 25613, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5287
+assert_return(() => invoke($32, `checkRange`, [25613, 25830, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5289
+assert_return(() => invoke($32, `checkRange`, [25830, 26446, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5291
+assert_return(() => invoke($32, `checkRange`, [26446, 26517, 10]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5293
+assert_return(() => invoke($32, `checkRange`, [26517, 27468, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5295
+assert_return(() => invoke($32, `checkRange`, [27468, 27503, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5297
+assert_return(() => invoke($32, `checkRange`, [27503, 27573, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5299
+assert_return(() => invoke($32, `checkRange`, [27573, 28245, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5301
+assert_return(() => invoke($32, `checkRange`, [28245, 28280, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5303
+assert_return(() => invoke($32, `checkRange`, [28280, 29502, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5305
+assert_return(() => invoke($32, `checkRange`, [29502, 29629, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5307
+assert_return(() => invoke($32, `checkRange`, [29629, 30387, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5309
+assert_return(() => invoke($32, `checkRange`, [30387, 30646, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5311
+assert_return(() => invoke($32, `checkRange`, [30646, 31066, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5313
+assert_return(() => invoke($32, `checkRange`, [31066, 31131, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5315
+assert_return(() => invoke($32, `checkRange`, [31131, 31322, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5317
+assert_return(() => invoke($32, `checkRange`, [31322, 31379, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5319
+assert_return(() => invoke($32, `checkRange`, [31379, 31403, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5321
+assert_return(() => invoke($32, `checkRange`, [31403, 31454, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5323
+assert_return(() => invoke($32, `checkRange`, [31454, 31463, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5325
+assert_return(() => invoke($32, `checkRange`, [31463, 31482, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5327
+assert_return(() => invoke($32, `checkRange`, [31482, 31649, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5329
+assert_return(() => invoke($32, `checkRange`, [31649, 31978, 72]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5331
+assert_return(() => invoke($32, `checkRange`, [31978, 32145, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5333
+assert_return(() => invoke($32, `checkRange`, [32145, 32530, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5335
+assert_return(() => invoke($32, `checkRange`, [32530, 32766, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5337
+assert_return(() => invoke($32, `checkRange`, [32766, 32812, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5339
+assert_return(() => invoke($32, `checkRange`, [32812, 33056, 68]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5341
+assert_return(() => invoke($32, `checkRange`, [33056, 33660, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5343
+assert_return(() => invoke($32, `checkRange`, [33660, 33752, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5345
+assert_return(() => invoke($32, `checkRange`, [33752, 33775, 36]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5347
+assert_return(() => invoke($32, `checkRange`, [33775, 33778, 32]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5349
+assert_return(() => invoke($32, `checkRange`, [33778, 34603, 9]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5351
+assert_return(() => invoke($32, `checkRange`, [34603, 35218, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5353
+assert_return(() => invoke($32, `checkRange`, [35218, 35372, 10]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5355
+assert_return(() => invoke($32, `checkRange`, [35372, 35486, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5357
+assert_return(() => invoke($32, `checkRange`, [35486, 35605, 5]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5359
+assert_return(() => invoke($32, `checkRange`, [35605, 35629, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5361
+assert_return(() => invoke($32, `checkRange`, [35629, 35648, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5363
+assert_return(() => invoke($32, `checkRange`, [35648, 36547, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5365
+assert_return(() => invoke($32, `checkRange`, [36547, 36755, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5367
+assert_return(() => invoke($32, `checkRange`, [36755, 36767, 93]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5369
+assert_return(() => invoke($32, `checkRange`, [36767, 36810, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5371
+assert_return(() => invoke($32, `checkRange`, [36810, 36839, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5373
+assert_return(() => invoke($32, `checkRange`, [36839, 37444, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5375
+assert_return(() => invoke($32, `checkRange`, [37444, 38060, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5377
+assert_return(() => invoke($32, `checkRange`, [38060, 38131, 10]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5379
+assert_return(() => invoke($32, `checkRange`, [38131, 39082, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5381
+assert_return(() => invoke($32, `checkRange`, [39082, 39117, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5383
+assert_return(() => invoke($32, `checkRange`, [39117, 39187, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5385
+assert_return(() => invoke($32, `checkRange`, [39187, 39859, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5387
+assert_return(() => invoke($32, `checkRange`, [39859, 39894, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5389
+assert_return(() => invoke($32, `checkRange`, [39894, 40257, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5391
+assert_return(() => invoke($32, `checkRange`, [40257, 40344, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5393
+assert_return(() => invoke($32, `checkRange`, [40344, 40371, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5395
+assert_return(() => invoke($32, `checkRange`, [40371, 40804, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5397
+assert_return(() => invoke($32, `checkRange`, [40804, 40909, 5]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5399
+assert_return(() => invoke($32, `checkRange`, [40909, 42259, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5401
+assert_return(() => invoke($32, `checkRange`, [42259, 42511, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5403
+assert_return(() => invoke($32, `checkRange`, [42511, 42945, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5405
+assert_return(() => invoke($32, `checkRange`, [42945, 43115, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5407
+assert_return(() => invoke($32, `checkRange`, [43115, 43306, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5409
+assert_return(() => invoke($32, `checkRange`, [43306, 43363, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5411
+assert_return(() => invoke($32, `checkRange`, [43363, 43387, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5413
+assert_return(() => invoke($32, `checkRange`, [43387, 43438, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5415
+assert_return(() => invoke($32, `checkRange`, [43438, 43447, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5417
+assert_return(() => invoke($32, `checkRange`, [43447, 43466, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5419
+assert_return(() => invoke($32, `checkRange`, [43466, 44129, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5421
+assert_return(() => invoke($32, `checkRange`, [44129, 44958, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5423
+assert_return(() => invoke($32, `checkRange`, [44958, 45570, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5425
+assert_return(() => invoke($32, `checkRange`, [45570, 45575, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5427
+assert_return(() => invoke($32, `checkRange`, [45575, 45640, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5429
+assert_return(() => invoke($32, `checkRange`, [45640, 45742, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5431
+assert_return(() => invoke($32, `checkRange`, [45742, 45832, 72]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5433
+assert_return(() => invoke($32, `checkRange`, [45832, 45999, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5435
+assert_return(() => invoke($32, `checkRange`, [45999, 46384, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5437
+assert_return(() => invoke($32, `checkRange`, [46384, 46596, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5439
+assert_return(() => invoke($32, `checkRange`, [46596, 46654, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5441
+assert_return(() => invoke($32, `checkRange`, [46654, 47515, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5443
+assert_return(() => invoke($32, `checkRange`, [47515, 47620, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5445
+assert_return(() => invoke($32, `checkRange`, [47620, 47817, 79]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5447
+assert_return(() => invoke($32, `checkRange`, [47817, 47951, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5449
+assert_return(() => invoke($32, `checkRange`, [47951, 48632, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5451
+assert_return(() => invoke($32, `checkRange`, [48632, 48699, 97]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5453
+assert_return(() => invoke($32, `checkRange`, [48699, 48703, 37]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5455
+assert_return(() => invoke($32, `checkRange`, [48703, 49764, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5457
+assert_return(() => invoke($32, `checkRange`, [49764, 49955, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5459
+assert_return(() => invoke($32, `checkRange`, [49955, 50012, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5461
+assert_return(() => invoke($32, `checkRange`, [50012, 50036, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5463
+assert_return(() => invoke($32, `checkRange`, [50036, 50087, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5465
+assert_return(() => invoke($32, `checkRange`, [50087, 50096, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5467
+assert_return(() => invoke($32, `checkRange`, [50096, 50115, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5469
+assert_return(() => invoke($32, `checkRange`, [50115, 50370, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5471
+assert_return(() => invoke($32, `checkRange`, [50370, 51358, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5473
+assert_return(() => invoke($32, `checkRange`, [51358, 51610, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5475
+assert_return(() => invoke($32, `checkRange`, [51610, 51776, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5477
+assert_return(() => invoke($32, `checkRange`, [51776, 51833, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5479
+assert_return(() => invoke($32, `checkRange`, [51833, 52895, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5481
+assert_return(() => invoke($32, `checkRange`, [52895, 53029, 97]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5483
+assert_return(() => invoke($32, `checkRange`, [53029, 53244, 68]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5485
+assert_return(() => invoke($32, `checkRange`, [53244, 54066, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5487
+assert_return(() => invoke($32, `checkRange`, [54066, 54133, 97]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5489
+assert_return(() => invoke($32, `checkRange`, [54133, 54137, 37]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5491
+assert_return(() => invoke($32, `checkRange`, [54137, 55198, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5493
+assert_return(() => invoke($32, `checkRange`, [55198, 55389, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5495
+assert_return(() => invoke($32, `checkRange`, [55389, 55446, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5497
+assert_return(() => invoke($32, `checkRange`, [55446, 55470, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5499
+assert_return(() => invoke($32, `checkRange`, [55470, 55521, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5501
+assert_return(() => invoke($32, `checkRange`, [55521, 55530, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5503
+assert_return(() => invoke($32, `checkRange`, [55530, 55549, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5505
+assert_return(() => invoke($32, `checkRange`, [55549, 56212, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5507
+assert_return(() => invoke($32, `checkRange`, [56212, 57048, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5509
+assert_return(() => invoke($32, `checkRange`, [57048, 58183, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5511
+assert_return(() => invoke($32, `checkRange`, [58183, 58202, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5513
+assert_return(() => invoke($32, `checkRange`, [58202, 58516, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5515
+assert_return(() => invoke($32, `checkRange`, [58516, 58835, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5517
+assert_return(() => invoke($32, `checkRange`, [58835, 58855, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5519
+assert_return(() => invoke($32, `checkRange`, [58855, 59089, 95]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5521
+assert_return(() => invoke($32, `checkRange`, [59089, 59145, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5523
+assert_return(() => invoke($32, `checkRange`, [59145, 59677, 99]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5525
+assert_return(() => invoke($32, `checkRange`, [59677, 60134, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5527
+assert_return(() => invoke($32, `checkRange`, [60134, 60502, 89]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5529
+assert_return(() => invoke($32, `checkRange`, [60502, 60594, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5531
+assert_return(() => invoke($32, `checkRange`, [60594, 60617, 36]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5533
+assert_return(() => invoke($32, `checkRange`, [60617, 60618, 32]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5535
+assert_return(() => invoke($32, `checkRange`, [60618, 60777, 42]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5537
+assert_return(() => invoke($32, `checkRange`, [60777, 60834, 76]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5539
+assert_return(() => invoke($32, `checkRange`, [60834, 60858, 57]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5541
+assert_return(() => invoke($32, `checkRange`, [60858, 60909, 59]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5543
+assert_return(() => invoke($32, `checkRange`, [60909, 60918, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5545
+assert_return(() => invoke($32, `checkRange`, [60918, 60937, 41]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5547
+assert_return(() => invoke($32, `checkRange`, [60937, 61600, 83]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5549
+assert_return(() => invoke($32, `checkRange`, [61600, 62436, 96]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5551
+assert_return(() => invoke($32, `checkRange`, [62436, 63307, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5553
+assert_return(() => invoke($32, `checkRange`, [63307, 63397, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5555
+assert_return(() => invoke($32, `checkRange`, [63397, 63501, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5557
+assert_return(() => invoke($32, `checkRange`, [63501, 63525, 93]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5559
+assert_return(() => invoke($32, `checkRange`, [63525, 63605, 74]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5561
+assert_return(() => invoke($32, `checkRange`, [63605, 63704, 100]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5563
+assert_return(() => invoke($32, `checkRange`, [63704, 63771, 97]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5565
+assert_return(() => invoke($32, `checkRange`, [63771, 63775, 37]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5567
+assert_return(() => invoke($32, `checkRange`, [63775, 64311, 77]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5569
+assert_return(() => invoke($32, `checkRange`, [64311, 64331, 26]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5571
+assert_return(() => invoke($32, `checkRange`, [64331, 64518, 92]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5573
+assert_return(() => invoke($32, `checkRange`, [64518, 64827, 11]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5575
+assert_return(() => invoke($32, `checkRange`, [64827, 64834, 26]), [value("i32", -1)]);
+
+// ./test/core/memory_copy.wast:5577
+assert_return(() => invoke($32, `checkRange`, [64834, 65536, 0]), [value("i32", -1)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory_fill.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory_fill.wast.js
new file mode 100644
index 0000000000..f0a122fc66
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory_fill.wast.js
@@ -0,0 +1,865 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_fill.wast
+
+// ./test/core/memory_fill.wast:6
+let $0 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256))))`);
+
+// ./test/core/memory_fill.wast:22
+invoke($0, `test`, []);
+
+// ./test/core/memory_fill.wast:24
+assert_return(() => invoke($0, `checkRange`, [0, 65280, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:26
+assert_return(() => invoke($0, `checkRange`, [65280, 65536, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:28
+let $1 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257))))`);
+
+// ./test/core/memory_fill.wast:44
+assert_trap(() => invoke($1, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_fill.wast:46
+let $2 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257))))`);
+
+// ./test/core/memory_fill.wast:62
+assert_trap(() => invoke($2, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_fill.wast:64
+let $3 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0))))`);
+
+// ./test/core/memory_fill.wast:80
+invoke($3, `test`, []);
+
+// ./test/core/memory_fill.wast:82
+assert_return(() => invoke($3, `checkRange`, [0, 65536, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:84
+let $4 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0))))`);
+
+// ./test/core/memory_fill.wast:100
+invoke($4, `test`, []);
+
+// ./test/core/memory_fill.wast:102
+let $5 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0))))`);
+
+// ./test/core/memory_fill.wast:118
+assert_trap(() => invoke($5, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_fill.wast:120
+let $6 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE))))`);
+
+// ./test/core/memory_fill.wast:136
+invoke($6, `test`, []);
+
+// ./test/core/memory_fill.wast:138
+assert_return(() => invoke($6, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:140
+assert_return(() => invoke($6, `checkRange`, [1, 65535, 170]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:142
+assert_return(() => invoke($6, `checkRange`, [65535, 65536, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:145
+let $7 = instantiate(`(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "test")
+     (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10))
+     (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4))))`);
+
+// ./test/core/memory_fill.wast:162
+invoke($7, `test`, []);
+
+// ./test/core/memory_fill.wast:164
+assert_return(() => invoke($7, `checkRange`, [0, 18, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:166
+assert_return(() => invoke($7, `checkRange`, [18, 21, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:168
+assert_return(() => invoke($7, `checkRange`, [21, 25, 170]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:170
+assert_return(() => invoke($7, `checkRange`, [25, 28, 85]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:172
+assert_return(() => invoke($7, `checkRange`, [28, 65536, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:174
+assert_invalid(
+  () => instantiate(`(module
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i32.const 30))))`),
+  `unknown memory 0`,
+);
+
+// ./test/core/memory_fill.wast:180
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:187
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:194
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:201
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:208
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:215
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:222
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:229
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:236
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:243
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:250
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:257
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:264
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:271
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:278
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:285
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:292
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:299
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:306
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:313
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:320
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:327
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:334
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:341
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:348
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:355
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:362
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:369
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:376
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:383
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:390
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:397
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:404
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:411
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:418
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:425
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:432
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:439
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:446
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:453
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:460
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:467
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:474
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:481
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:488
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:495
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:502
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:509
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:516
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:523
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:530
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:537
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:544
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:551
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:558
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:565
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:572
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:579
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:586
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:593
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:600
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f32.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:607
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:614
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f64.const 30))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_fill.wast:621
+let $8 = instantiate(`(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$val i32) (param $$len i32)
+    (memory.fill (local.get $$offs) (local.get $$val) (local.get $$len))))`);
+
+// ./test/core/memory_fill.wast:638
+assert_trap(() => invoke($8, `run`, [65280, 37, 512]), `out of bounds memory access`);
+
+// ./test/core/memory_fill.wast:641
+assert_return(() => invoke($8, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:643
+let $9 = instantiate(`(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$val i32) (param $$len i32)
+    (memory.fill (local.get $$offs) (local.get $$val) (local.get $$len))))`);
+
+// ./test/core/memory_fill.wast:660
+assert_trap(() => invoke($9, `run`, [65279, 37, 514]), `out of bounds memory access`);
+
+// ./test/core/memory_fill.wast:663
+assert_return(() => invoke($9, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_fill.wast:665
+let $10 = instantiate(`(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$val i32) (param $$len i32)
+    (memory.fill (local.get $$offs) (local.get $$val) (local.get $$len))))`);
+
+// ./test/core/memory_fill.wast:682
+assert_trap(() => invoke($10, `run`, [65279, 37, -1]), `out of bounds memory access`);
+
+// ./test/core/memory_fill.wast:685
+assert_return(() => invoke($10, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory_grow.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory_grow.wast.js
new file mode 100644
index 0000000000..fafa7007f4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory_grow.wast.js
@@ -0,0 +1,555 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_grow.wast
+
+// ./test/core/memory_grow.wast:1
+let $0 = instantiate(`(module
+    (memory 0)
+
+    (func (export "load_at_zero") (result i32) (i32.load (i32.const 0)))
+    (func (export "store_at_zero") (i32.store (i32.const 0) (i32.const 2)))
+
+    (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000)))
+    (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3)))
+
+    (func (export "grow") (param $$sz i32) (result i32) (memory.grow (local.get $$sz)))
+    (func (export "size") (result i32) (memory.size))
+)`);
+
+// ./test/core/memory_grow.wast:14
+assert_return(() => invoke($0, `size`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:15
+assert_trap(() => invoke($0, `store_at_zero`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow.wast:16
+assert_trap(() => invoke($0, `load_at_zero`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow.wast:17
+assert_trap(() => invoke($0, `store_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow.wast:18
+assert_trap(() => invoke($0, `load_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow.wast:19
+assert_return(() => invoke($0, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:20
+assert_return(() => invoke($0, `size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:21
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:22
+assert_return(() => invoke($0, `store_at_zero`, []), []);
+
+// ./test/core/memory_grow.wast:23
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 2)]);
+
+// ./test/core/memory_grow.wast:24
+assert_trap(() => invoke($0, `store_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow.wast:25
+assert_trap(() => invoke($0, `load_at_page_size`, []), `out of bounds memory access`);
+
+// ./test/core/memory_grow.wast:26
+assert_return(() => invoke($0, `grow`, [4]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:27
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/memory_grow.wast:28
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 2)]);
+
+// ./test/core/memory_grow.wast:29
+assert_return(() => invoke($0, `store_at_zero`, []), []);
+
+// ./test/core/memory_grow.wast:30
+assert_return(() => invoke($0, `load_at_zero`, []), [value("i32", 2)]);
+
+// ./test/core/memory_grow.wast:31
+assert_return(() => invoke($0, `load_at_page_size`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:32
+assert_return(() => invoke($0, `store_at_page_size`, []), []);
+
+// ./test/core/memory_grow.wast:33
+assert_return(() => invoke($0, `load_at_page_size`, []), [value("i32", 3)]);
+
+// ./test/core/memory_grow.wast:36
+let $1 = instantiate(`(module
+  (memory 0)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)`);
+
+// ./test/core/memory_grow.wast:41
+assert_return(() => invoke($1, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:42
+assert_return(() => invoke($1, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:43
+assert_return(() => invoke($1, `grow`, [0]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:44
+assert_return(() => invoke($1, `grow`, [2]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:45
+assert_return(() => invoke($1, `grow`, [800]), [value("i32", 3)]);
+
+// ./test/core/memory_grow.wast:46
+assert_return(() => invoke($1, `grow`, [65536]), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:47
+assert_return(() => invoke($1, `grow`, [64736]), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:48
+assert_return(() => invoke($1, `grow`, [1]), [value("i32", 803)]);
+
+// ./test/core/memory_grow.wast:50
+let $2 = instantiate(`(module
+  (memory 0 10)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)`);
+
+// ./test/core/memory_grow.wast:55
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:56
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:57
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:58
+assert_return(() => invoke($2, `grow`, [2]), [value("i32", 2)]);
+
+// ./test/core/memory_grow.wast:59
+assert_return(() => invoke($2, `grow`, [6]), [value("i32", 4)]);
+
+// ./test/core/memory_grow.wast:60
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 10)]);
+
+// ./test/core/memory_grow.wast:61
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:62
+assert_return(() => invoke($2, `grow`, [65536]), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:66
+let $3 = instantiate(`(module
+  (memory 1)
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+  (func (export "check-memory-zero") (param i32 i32) (result i32)
+    (local i32)
+    (local.set 2 (i32.const 1))
+    (block
+      (loop
+        (local.set 2 (i32.load8_u (local.get 0)))
+        (br_if 1 (i32.ne (local.get 2) (i32.const 0)))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)`);
+
+// ./test/core/memory_grow.wast:87
+assert_return(() => invoke($3, `check-memory-zero`, [0, 65535]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:88
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:89
+assert_return(() => invoke($3, `check-memory-zero`, [65536, 131071]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:90
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 2)]);
+
+// ./test/core/memory_grow.wast:91
+assert_return(() => invoke($3, `check-memory-zero`, [131072, 196607]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:92
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 3)]);
+
+// ./test/core/memory_grow.wast:93
+assert_return(() => invoke($3, `check-memory-zero`, [196608, 262143]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:94
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 4)]);
+
+// ./test/core/memory_grow.wast:95
+assert_return(() => invoke($3, `check-memory-zero`, [262144, 327679]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:96
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 5)]);
+
+// ./test/core/memory_grow.wast:97
+assert_return(() => invoke($3, `check-memory-zero`, [327680, 393215]), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:101
+let $4 = instantiate(`(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (memory.grow (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (memory.grow (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (memory.grow (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (memory.grow (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (memory.grow (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (memory.grow (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (memory.grow (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (memory.grow (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (memory.grow (i32.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (memory.grow (i32.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0)))
+  )
+
+  (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $$f (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $$f (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $$f (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (type $$sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $$sig)
+      (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (memory.grow (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (memory.grow (i32.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (memory.grow (i32.const 0)))
+  )
+  (global $$g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $$g (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (memory.grow (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (memory.grow (i32.const 0)))
+  )
+)`);
+
+// ./test/core/memory_grow.wast:259
+assert_return(() => invoke($4, `as-br-value`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:261
+assert_return(() => invoke($4, `as-br_if-cond`, []), []);
+
+// ./test/core/memory_grow.wast:262
+assert_return(() => invoke($4, `as-br_if-value`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:263
+assert_return(() => invoke($4, `as-br_if-value-cond`, []), [value("i32", 6)]);
+
+// ./test/core/memory_grow.wast:265
+assert_return(() => invoke($4, `as-br_table-index`, []), []);
+
+// ./test/core/memory_grow.wast:266
+assert_return(() => invoke($4, `as-br_table-value`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:267
+assert_return(() => invoke($4, `as-br_table-value-index`, []), [value("i32", 6)]);
+
+// ./test/core/memory_grow.wast:269
+assert_return(() => invoke($4, `as-return-value`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:271
+assert_return(() => invoke($4, `as-if-cond`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:272
+assert_return(() => invoke($4, `as-if-then`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:273
+assert_return(() => invoke($4, `as-if-else`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:275
+assert_return(() => invoke($4, `as-select-first`, [0, 1]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:276
+assert_return(() => invoke($4, `as-select-second`, [0, 0]), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:277
+assert_return(() => invoke($4, `as-select-cond`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:279
+assert_return(() => invoke($4, `as-call-first`, []), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:280
+assert_return(() => invoke($4, `as-call-mid`, []), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:281
+assert_return(() => invoke($4, `as-call-last`, []), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:283
+assert_return(() => invoke($4, `as-call_indirect-first`, []), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:284
+assert_return(() => invoke($4, `as-call_indirect-mid`, []), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:285
+assert_return(() => invoke($4, `as-call_indirect-last`, []), [value("i32", -1)]);
+
+// ./test/core/memory_grow.wast:286
+assert_trap(() => invoke($4, `as-call_indirect-index`, []), `undefined element`);
+
+// ./test/core/memory_grow.wast:288
+assert_return(() => invoke($4, `as-local.set-value`, []), []);
+
+// ./test/core/memory_grow.wast:289
+assert_return(() => invoke($4, `as-local.tee-value`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:290
+assert_return(() => invoke($4, `as-global.set-value`, []), []);
+
+// ./test/core/memory_grow.wast:292
+assert_return(() => invoke($4, `as-load-address`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:293
+assert_return(() => invoke($4, `as-loadN-address`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:294
+assert_return(() => invoke($4, `as-store-address`, []), []);
+
+// ./test/core/memory_grow.wast:295
+assert_return(() => invoke($4, `as-store-value`, []), []);
+
+// ./test/core/memory_grow.wast:296
+assert_return(() => invoke($4, `as-storeN-address`, []), []);
+
+// ./test/core/memory_grow.wast:297
+assert_return(() => invoke($4, `as-storeN-value`, []), []);
+
+// ./test/core/memory_grow.wast:299
+assert_return(() => invoke($4, `as-unary-operand`, []), [value("i32", 31)]);
+
+// ./test/core/memory_grow.wast:301
+assert_return(() => invoke($4, `as-binary-left`, []), [value("i32", 11)]);
+
+// ./test/core/memory_grow.wast:302
+assert_return(() => invoke($4, `as-binary-right`, []), [value("i32", 9)]);
+
+// ./test/core/memory_grow.wast:304
+assert_return(() => invoke($4, `as-test-operand`, []), [value("i32", 0)]);
+
+// ./test/core/memory_grow.wast:306
+assert_return(() => invoke($4, `as-compare-left`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:307
+assert_return(() => invoke($4, `as-compare-right`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:309
+assert_return(() => invoke($4, `as-memory.grow-size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_grow.wast:312
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-size-empty-vs-i32 (result i32)
+      (memory.grow)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_grow.wast:321
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-size-empty-vs-i32-in-block (result i32)
+      (i32.const 0)
+      (block (result i32) (memory.grow))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_grow.wast:331
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-size-empty-vs-i32-in-loop (result i32)
+      (i32.const 0)
+      (loop (result i32) (memory.grow))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_grow.wast:341
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-size-empty-vs-i32-in-then (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (memory.grow)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_grow.wast:352
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-size-f32-vs-i32 (result i32)
+      (memory.grow (f32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_grow.wast:362
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-result-i32-vs-empty
+      (memory.grow (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_grow.wast:371
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (memory.grow (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory_init.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory_init.wast.js
new file mode 100644
index 0000000000..9885c42f81
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory_init.wast.js
@@ -0,0 +1,1409 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_init.wast
+
+// ./test/core/memory_init.wast:6
+let $0 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data "\\02\\07\\01\\08")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (data "\\05\\09\\02\\07\\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_init.wast:17
+invoke($0, `test`, []);
+
+// ./test/core/memory_init.wast:19
+assert_return(() => invoke($0, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:20
+assert_return(() => invoke($0, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:21
+assert_return(() => invoke($0, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_init.wast:22
+assert_return(() => invoke($0, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:23
+assert_return(() => invoke($0, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_init.wast:24
+assert_return(() => invoke($0, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:25
+assert_return(() => invoke($0, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:26
+assert_return(() => invoke($0, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:27
+assert_return(() => invoke($0, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:28
+assert_return(() => invoke($0, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:29
+assert_return(() => invoke($0, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:30
+assert_return(() => invoke($0, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:31
+assert_return(() => invoke($0, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:32
+assert_return(() => invoke($0, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_init.wast:33
+assert_return(() => invoke($0, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:34
+assert_return(() => invoke($0, `load8_u`, [15]), [value("i32", 3)]);
+
+// ./test/core/memory_init.wast:35
+assert_return(() => invoke($0, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_init.wast:36
+assert_return(() => invoke($0, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:37
+assert_return(() => invoke($0, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:38
+assert_return(() => invoke($0, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:39
+assert_return(() => invoke($0, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:40
+assert_return(() => invoke($0, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:41
+assert_return(() => invoke($0, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:42
+assert_return(() => invoke($0, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:43
+assert_return(() => invoke($0, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:44
+assert_return(() => invoke($0, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:45
+assert_return(() => invoke($0, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:46
+assert_return(() => invoke($0, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:47
+assert_return(() => invoke($0, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:48
+assert_return(() => invoke($0, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:50
+let $1 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data "\\02\\07\\01\\08")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (data "\\05\\09\\02\\07\\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_init.wast:61
+invoke($1, `test`, []);
+
+// ./test/core/memory_init.wast:63
+assert_return(() => invoke($1, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:64
+assert_return(() => invoke($1, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:65
+assert_return(() => invoke($1, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_init.wast:66
+assert_return(() => invoke($1, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:67
+assert_return(() => invoke($1, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_init.wast:68
+assert_return(() => invoke($1, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:69
+assert_return(() => invoke($1, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:70
+assert_return(() => invoke($1, `load8_u`, [7]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:71
+assert_return(() => invoke($1, `load8_u`, [8]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:72
+assert_return(() => invoke($1, `load8_u`, [9]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:73
+assert_return(() => invoke($1, `load8_u`, [10]), [value("i32", 8)]);
+
+// ./test/core/memory_init.wast:74
+assert_return(() => invoke($1, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:75
+assert_return(() => invoke($1, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:76
+assert_return(() => invoke($1, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_init.wast:77
+assert_return(() => invoke($1, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:78
+assert_return(() => invoke($1, `load8_u`, [15]), [value("i32", 3)]);
+
+// ./test/core/memory_init.wast:79
+assert_return(() => invoke($1, `load8_u`, [16]), [value("i32", 6)]);
+
+// ./test/core/memory_init.wast:80
+assert_return(() => invoke($1, `load8_u`, [17]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:81
+assert_return(() => invoke($1, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:82
+assert_return(() => invoke($1, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:83
+assert_return(() => invoke($1, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:84
+assert_return(() => invoke($1, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:85
+assert_return(() => invoke($1, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:86
+assert_return(() => invoke($1, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:87
+assert_return(() => invoke($1, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:88
+assert_return(() => invoke($1, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:89
+assert_return(() => invoke($1, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:90
+assert_return(() => invoke($1, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:91
+assert_return(() => invoke($1, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:92
+assert_return(() => invoke($1, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:94
+let $2 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data "\\02\\07\\01\\08")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (data "\\05\\09\\02\\07\\06")
+  (func (export "test")
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_init.wast:105
+invoke($2, `test`, []);
+
+// ./test/core/memory_init.wast:107
+assert_return(() => invoke($2, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:108
+assert_return(() => invoke($2, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:109
+assert_return(() => invoke($2, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_init.wast:110
+assert_return(() => invoke($2, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:111
+assert_return(() => invoke($2, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_init.wast:112
+assert_return(() => invoke($2, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:113
+assert_return(() => invoke($2, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:114
+assert_return(() => invoke($2, `load8_u`, [7]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:115
+assert_return(() => invoke($2, `load8_u`, [8]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:116
+assert_return(() => invoke($2, `load8_u`, [9]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:117
+assert_return(() => invoke($2, `load8_u`, [10]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:118
+assert_return(() => invoke($2, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:119
+assert_return(() => invoke($2, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:120
+assert_return(() => invoke($2, `load8_u`, [13]), [value("i32", 5)]);
+
+// ./test/core/memory_init.wast:121
+assert_return(() => invoke($2, `load8_u`, [14]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:122
+assert_return(() => invoke($2, `load8_u`, [15]), [value("i32", 9)]);
+
+// ./test/core/memory_init.wast:123
+assert_return(() => invoke($2, `load8_u`, [16]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:124
+assert_return(() => invoke($2, `load8_u`, [17]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:125
+assert_return(() => invoke($2, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:126
+assert_return(() => invoke($2, `load8_u`, [19]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:127
+assert_return(() => invoke($2, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:128
+assert_return(() => invoke($2, `load8_u`, [21]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:129
+assert_return(() => invoke($2, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:130
+assert_return(() => invoke($2, `load8_u`, [23]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:131
+assert_return(() => invoke($2, `load8_u`, [24]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:132
+assert_return(() => invoke($2, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:133
+assert_return(() => invoke($2, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:134
+assert_return(() => invoke($2, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:135
+assert_return(() => invoke($2, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:136
+assert_return(() => invoke($2, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:138
+let $3 = instantiate(`(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\\03\\01\\04\\01")
+  (data "\\02\\07\\01\\08")
+  (data (i32.const 12) "\\07\\05\\02\\03\\06")
+  (data "\\05\\09\\02\\07\\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (data.drop 1)
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (data.drop 3)
+    (memory.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (memory.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (memory.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (memory.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (memory.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))`);
+
+// ./test/core/memory_init.wast:157
+invoke($3, `test`, []);
+
+// ./test/core/memory_init.wast:159
+assert_return(() => invoke($3, `load8_u`, [0]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:160
+assert_return(() => invoke($3, `load8_u`, [1]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:161
+assert_return(() => invoke($3, `load8_u`, [2]), [value("i32", 3)]);
+
+// ./test/core/memory_init.wast:162
+assert_return(() => invoke($3, `load8_u`, [3]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:163
+assert_return(() => invoke($3, `load8_u`, [4]), [value("i32", 4)]);
+
+// ./test/core/memory_init.wast:164
+assert_return(() => invoke($3, `load8_u`, [5]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:165
+assert_return(() => invoke($3, `load8_u`, [6]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:166
+assert_return(() => invoke($3, `load8_u`, [7]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:167
+assert_return(() => invoke($3, `load8_u`, [8]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:168
+assert_return(() => invoke($3, `load8_u`, [9]), [value("i32", 1)]);
+
+// ./test/core/memory_init.wast:169
+assert_return(() => invoke($3, `load8_u`, [10]), [value("i32", 8)]);
+
+// ./test/core/memory_init.wast:170
+assert_return(() => invoke($3, `load8_u`, [11]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:171
+assert_return(() => invoke($3, `load8_u`, [12]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:172
+assert_return(() => invoke($3, `load8_u`, [13]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:173
+assert_return(() => invoke($3, `load8_u`, [14]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:174
+assert_return(() => invoke($3, `load8_u`, [15]), [value("i32", 5)]);
+
+// ./test/core/memory_init.wast:175
+assert_return(() => invoke($3, `load8_u`, [16]), [value("i32", 2)]);
+
+// ./test/core/memory_init.wast:176
+assert_return(() => invoke($3, `load8_u`, [17]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:177
+assert_return(() => invoke($3, `load8_u`, [18]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:178
+assert_return(() => invoke($3, `load8_u`, [19]), [value("i32", 9)]);
+
+// ./test/core/memory_init.wast:179
+assert_return(() => invoke($3, `load8_u`, [20]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:180
+assert_return(() => invoke($3, `load8_u`, [21]), [value("i32", 7)]);
+
+// ./test/core/memory_init.wast:181
+assert_return(() => invoke($3, `load8_u`, [22]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:182
+assert_return(() => invoke($3, `load8_u`, [23]), [value("i32", 8)]);
+
+// ./test/core/memory_init.wast:183
+assert_return(() => invoke($3, `load8_u`, [24]), [value("i32", 8)]);
+
+// ./test/core/memory_init.wast:184
+assert_return(() => invoke($3, `load8_u`, [25]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:185
+assert_return(() => invoke($3, `load8_u`, [26]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:186
+assert_return(() => invoke($3, `load8_u`, [27]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:187
+assert_return(() => invoke($3, `load8_u`, [28]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:188
+assert_return(() => invoke($3, `load8_u`, [29]), [value("i32", 0)]);
+
+// ./test/core/memory_init.wast:189
+assert_invalid(
+  () => instantiate(`(module
+     (func (export "test")
+       (data.drop 0)))`),
+  `unknown data segment`,
+);
+
+// ./test/core/memory_init.wast:195
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (data.drop 4)))`),
+  `unknown data segment`,
+);
+
+// ./test/core/memory_init.wast:203
+let $4 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (data.drop 0)
+    (data.drop 0)))`);
+
+// ./test/core/memory_init.wast:209
+invoke($4, `test`, []);
+
+// ./test/core/memory_init.wast:211
+let $5 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (data.drop 0)
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))`);
+
+// ./test/core/memory_init.wast:217
+assert_trap(() => invoke($5, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:219
+let $6 = instantiate(`(module
+   (memory 1)
+   (data (i32.const 0) "\\37")
+   (func (export "test")
+     (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))`);
+
+// ./test/core/memory_init.wast:224
+assert_trap(() => invoke($6, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:226
+assert_invalid(
+  () => instantiate(`(module
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))`),
+  `unknown memory 0`,
+);
+
+// ./test/core/memory_init.wast:232
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))`),
+  `unknown data segment 1`,
+);
+
+// ./test/core/memory_init.wast:240
+let $7 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))))`);
+
+// ./test/core/memory_init.wast:246
+invoke($7, `test`, []);
+
+// ./test/core/memory_init.wast:248
+let $8 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5))))`);
+
+// ./test/core/memory_init.wast:253
+assert_trap(() => invoke($8, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:255
+let $9 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3))))`);
+
+// ./test/core/memory_init.wast:260
+assert_trap(() => invoke($9, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:262
+let $10 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3))))`);
+
+// ./test/core/memory_init.wast:267
+assert_trap(() => invoke($10, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:269
+let $11 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0))))`);
+
+// ./test/core/memory_init.wast:274
+assert_trap(() => invoke($11, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:276
+let $12 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 0))))`);
+
+// ./test/core/memory_init.wast:281
+invoke($12, `test`, []);
+
+// ./test/core/memory_init.wast:283
+let $13 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0))))`);
+
+// ./test/core/memory_init.wast:288
+assert_trap(() => invoke($13, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:290
+let $14 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 0) (i32.const 0))))`);
+
+// ./test/core/memory_init.wast:295
+invoke($14, `test`, []);
+
+// ./test/core/memory_init.wast:297
+let $15 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 1) (i32.const 0))))`);
+
+// ./test/core/memory_init.wast:302
+invoke($15, `test`, []);
+
+// ./test/core/memory_init.wast:304
+let $16 = instantiate(`(module
+  (memory 1)
+    (data "\\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0))))`);
+
+// ./test/core/memory_init.wast:309
+assert_trap(() => invoke($16, `test`, []), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:311
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:319
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:327
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:335
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:343
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:351
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:359
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:367
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:375
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:383
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:391
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:399
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:407
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:415
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:423
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:431
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:439
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:447
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:455
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:463
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:471
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:479
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:487
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:495
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:503
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:511
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:519
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:527
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:535
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:543
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:551
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:559
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:567
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:575
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:583
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:591
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:599
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:607
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:615
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:623
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:631
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:639
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:647
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:655
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:663
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:671
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:679
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:687
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:695
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:703
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:711
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:719
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:727
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:735
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:743
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:751
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:759
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:767
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:775
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:783
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:791
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:799
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:807
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (data "\\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_init.wast:815
+let $17 = instantiate(`(module
+  (memory 1 1 )
+  (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+   
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (memory.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/memory_init.wast:833
+assert_trap(() => invoke($17, `run`, [65528, 16]), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:836
+assert_return(() => invoke($17, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_init.wast:838
+let $18 = instantiate(`(module
+  (memory 1 1 )
+  (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+   
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (memory.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/memory_init.wast:856
+assert_trap(() => invoke($18, `run`, [65527, 16]), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:859
+assert_return(() => invoke($18, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_init.wast:861
+let $19 = instantiate(`(module
+  (memory 1 1 )
+  (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+   
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (memory.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/memory_init.wast:879
+assert_trap(() => invoke($19, `run`, [65472, 30]), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:882
+assert_return(() => invoke($19, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_init.wast:884
+let $20 = instantiate(`(module
+  (memory 1 1 )
+  (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+   
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (memory.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/memory_init.wast:902
+assert_trap(() => invoke($20, `run`, [65473, 31]), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:905
+assert_return(() => invoke($20, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_init.wast:907
+let $21 = instantiate(`(module
+  (memory 1  )
+  (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+   
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (memory.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/memory_init.wast:925
+assert_trap(() => invoke($21, `run`, [65528, -256]), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:928
+assert_return(() => invoke($21, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_init.wast:930
+let $22 = instantiate(`(module
+  (memory 1  )
+  (data "\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42\\42")
+   
+  (func (export "checkRange") (param $$from i32) (param $$to i32) (param $$expected i32) (result i32)
+    (loop $$cont
+      (if (i32.eq (local.get $$from) (local.get $$to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $$from)) (local.get $$expected))
+        (then
+          (local.set $$from (i32.add (local.get $$from) (i32.const 1)))
+          (br $$cont))))
+    (return (local.get $$from)))
+
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (memory.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/memory_init.wast:948
+assert_trap(() => invoke($22, `run`, [0, -4]), `out of bounds memory access`);
+
+// ./test/core/memory_init.wast:951
+assert_return(() => invoke($22, `checkRange`, [0, 1, 0]), [value("i32", -1)]);
+
+// ./test/core/memory_init.wast:954
+let $23 = instantiate(`(module
+  (memory 1)
+  ;; 65 data segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (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))))`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory_redundancy.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory_redundancy.wast.js
new file mode 100644
index 0000000000..cd2d894092
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory_redundancy.wast.js
@@ -0,0 +1,95 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_redundancy.wast
+
+// ./test/core/memory_redundancy.wast:5
+let $0 = instantiate(`(module
+  (memory 1 1)
+
+  (func (export "zero_everything")
+    (i32.store (i32.const 0) (i32.const 0))
+    (i32.store (i32.const 4) (i32.const 0))
+    (i32.store (i32.const 8) (i32.const 0))
+    (i32.store (i32.const 12) (i32.const 0))
+  )
+
+  (func (export "test_store_to_load") (result i32)
+    (i32.store (i32.const 8) (i32.const 0))
+    (f32.store (i32.const 5) (f32.const -0.0))
+    (i32.load (i32.const 8))
+  )
+
+  (func (export "test_redundant_load") (result i32)
+    (local $$t i32)
+    (local $$s i32)
+    (local.set $$t (i32.load (i32.const 8)))
+    (i32.store (i32.const 5) (i32.const 0x80000000))
+    (local.set $$s (i32.load (i32.const 8)))
+    (i32.add (local.get $$t) (local.get $$s))
+  )
+
+  (func (export "test_dead_store") (result f32)
+    (local $$t f32)
+    (i32.store (i32.const 8) (i32.const 0x23232323))
+    (local.set $$t (f32.load (i32.const 11)))
+    (i32.store (i32.const 8) (i32.const 0))
+    (local.get $$t)
+  )
+
+  ;; A function named "malloc" which implementations nonetheless shouldn't
+  ;; assume behaves like C malloc.
+  (func $$malloc (export "malloc")
+     (param $$size i32)
+     (result i32)
+     (i32.const 16)
+  )
+
+  ;; Call malloc twice, but unlike C malloc, we don't get non-aliasing pointers.
+  (func (export "malloc_aliasing")
+     (result i32)
+     (local $$x i32)
+     (local $$y i32)
+     (local.set $$x (call $$malloc (i32.const 4)))
+     (local.set $$y (call $$malloc (i32.const 4)))
+     (i32.store (local.get $$x) (i32.const 42))
+     (i32.store (local.get $$y) (i32.const 43))
+     (i32.load (local.get $$x))
+  )
+)`);
+
+// ./test/core/memory_redundancy.wast:59
+assert_return(() => invoke($0, `test_store_to_load`, []), [value("i32", 128)]);
+
+// ./test/core/memory_redundancy.wast:60
+invoke($0, `zero_everything`, []);
+
+// ./test/core/memory_redundancy.wast:61
+assert_return(() => invoke($0, `test_redundant_load`, []), [value("i32", 128)]);
+
+// ./test/core/memory_redundancy.wast:62
+invoke($0, `zero_everything`, []);
+
+// ./test/core/memory_redundancy.wast:63
+assert_return(
+  () => invoke($0, `test_dead_store`, []),
+  [value("f32", 0.000000000000000000000000000000000000000000049)],
+);
+
+// ./test/core/memory_redundancy.wast:64
+invoke($0, `zero_everything`, []);
+
+// ./test/core/memory_redundancy.wast:65
+assert_return(() => invoke($0, `malloc_aliasing`, []), [value("i32", 43)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/memory_size.wast.js b/js/src/jit-test/tests/wasm/spec/spec/memory_size.wast.js
new file mode 100644
index 0000000000..0ce58ebddf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/memory_size.wast.js
@@ -0,0 +1,174 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/memory_size.wast
+
+// ./test/core/memory_size.wast:1
+let $0 = instantiate(`(module
+  (memory 0)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $$sz i32) (drop (memory.grow (local.get $$sz))))
+)`);
+
+// ./test/core/memory_size.wast:7
+assert_return(() => invoke($0, `size`, []), [value("i32", 0)]);
+
+// ./test/core/memory_size.wast:8
+assert_return(() => invoke($0, `grow`, [1]), []);
+
+// ./test/core/memory_size.wast:9
+assert_return(() => invoke($0, `size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_size.wast:10
+assert_return(() => invoke($0, `grow`, [4]), []);
+
+// ./test/core/memory_size.wast:11
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/memory_size.wast:12
+assert_return(() => invoke($0, `grow`, [0]), []);
+
+// ./test/core/memory_size.wast:13
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/memory_size.wast:15
+let $1 = instantiate(`(module
+  (memory 1)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $$sz i32) (drop (memory.grow (local.get $$sz))))
+)`);
+
+// ./test/core/memory_size.wast:21
+assert_return(() => invoke($1, `size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_size.wast:22
+assert_return(() => invoke($1, `grow`, [1]), []);
+
+// ./test/core/memory_size.wast:23
+assert_return(() => invoke($1, `size`, []), [value("i32", 2)]);
+
+// ./test/core/memory_size.wast:24
+assert_return(() => invoke($1, `grow`, [4]), []);
+
+// ./test/core/memory_size.wast:25
+assert_return(() => invoke($1, `size`, []), [value("i32", 6)]);
+
+// ./test/core/memory_size.wast:26
+assert_return(() => invoke($1, `grow`, [0]), []);
+
+// ./test/core/memory_size.wast:27
+assert_return(() => invoke($1, `size`, []), [value("i32", 6)]);
+
+// ./test/core/memory_size.wast:29
+let $2 = instantiate(`(module
+  (memory 0 2)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $$sz i32) (drop (memory.grow (local.get $$sz))))
+)`);
+
+// ./test/core/memory_size.wast:35
+assert_return(() => invoke($2, `size`, []), [value("i32", 0)]);
+
+// ./test/core/memory_size.wast:36
+assert_return(() => invoke($2, `grow`, [3]), []);
+
+// ./test/core/memory_size.wast:37
+assert_return(() => invoke($2, `size`, []), [value("i32", 0)]);
+
+// ./test/core/memory_size.wast:38
+assert_return(() => invoke($2, `grow`, [1]), []);
+
+// ./test/core/memory_size.wast:39
+assert_return(() => invoke($2, `size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_size.wast:40
+assert_return(() => invoke($2, `grow`, [0]), []);
+
+// ./test/core/memory_size.wast:41
+assert_return(() => invoke($2, `size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_size.wast:42
+assert_return(() => invoke($2, `grow`, [4]), []);
+
+// ./test/core/memory_size.wast:43
+assert_return(() => invoke($2, `size`, []), [value("i32", 1)]);
+
+// ./test/core/memory_size.wast:44
+assert_return(() => invoke($2, `grow`, [1]), []);
+
+// ./test/core/memory_size.wast:45
+assert_return(() => invoke($2, `size`, []), [value("i32", 2)]);
+
+// ./test/core/memory_size.wast:47
+let $3 = instantiate(`(module
+  (memory 3 8)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $$sz i32) (drop (memory.grow (local.get $$sz))))
+)`);
+
+// ./test/core/memory_size.wast:53
+assert_return(() => invoke($3, `size`, []), [value("i32", 3)]);
+
+// ./test/core/memory_size.wast:54
+assert_return(() => invoke($3, `grow`, [1]), []);
+
+// ./test/core/memory_size.wast:55
+assert_return(() => invoke($3, `size`, []), [value("i32", 4)]);
+
+// ./test/core/memory_size.wast:56
+assert_return(() => invoke($3, `grow`, [3]), []);
+
+// ./test/core/memory_size.wast:57
+assert_return(() => invoke($3, `size`, []), [value("i32", 7)]);
+
+// ./test/core/memory_size.wast:58
+assert_return(() => invoke($3, `grow`, [0]), []);
+
+// ./test/core/memory_size.wast:59
+assert_return(() => invoke($3, `size`, []), [value("i32", 7)]);
+
+// ./test/core/memory_size.wast:60
+assert_return(() => invoke($3, `grow`, [2]), []);
+
+// ./test/core/memory_size.wast:61
+assert_return(() => invoke($3, `size`, []), [value("i32", 7)]);
+
+// ./test/core/memory_size.wast:62
+assert_return(() => invoke($3, `grow`, [1]), []);
+
+// ./test/core/memory_size.wast:63
+assert_return(() => invoke($3, `size`, []), [value("i32", 8)]);
+
+// ./test/core/memory_size.wast:68
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-result-i32-vs-empty
+      (memory.size)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/memory_size.wast:77
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (memory.size)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/names.wast.js b/js/src/jit-test/tests/wasm/spec/spec/names.wast.js
new file mode 100644
index 0000000000..351da9af19
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/names.wast.js
@@ -0,0 +1,2131 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/names.wast
+
+// ./test/core/names.wast:4
+let $0 = instantiate(`(module
+  (func (export "foo") (result i32) (i32.const 0))
+)`);
+
+// ./test/core/names.wast:8
+assert_return(() => invoke($0, `foo`, []), [value("i32", 0)]);
+
+// ./test/core/names.wast:12
+let $1 = instantiate(`(module
+  (func (export "foo") (result i32) (i32.const 1))
+)`);
+
+// ./test/core/names.wast:16
+assert_return(() => invoke($1, `foo`, []), [value("i32", 1)]);
+
+// ./test/core/names.wast:19
+let $2 = instantiate(`(module
+  ;; Test that we can use the empty string as a symbol.
+  (func (export "") (result i32) (i32.const 0))
+
+  ;; Test that we can use names beginning with a digit.
+  (func (export "0") (result i32) (i32.const 1))
+
+  ;; Test that we can use names beginning with a dash.
+  (func (export "-0") (result i32) (i32.const 2))
+
+  ;; Test that we can use names beginning with an underscore.
+  (func (export "_") (result i32) (i32.const 3))
+
+  ;; Test that we can use names beginning with a dollar sign.
+  (func (export "$$") (result i32) (i32.const 4))
+
+  ;; Test that we can use names beginning with an at sign.
+  (func (export "@") (result i32) (i32.const 5))
+
+  ;; Test that we can use non-alphanumeric names.
+  (func (export "~!@#$$%^&*()_+\`-={}|[]\\\\:\\";'<>?,./ ") (result i32) (i32.const 6))
+
+  ;; Test that we can use names that have special meaning in JS.
+  (func (export "NaN") (result i32) (i32.const 7))
+  (func (export "Infinity") (result i32) (i32.const 8))
+  (func (export "if") (result i32) (i32.const 9))
+
+  ;; Test that we can use common libc names without conflict.
+  (func (export "malloc") (result i32) (i32.const 10))
+
+  ;; Test that we can use some libc hidden names without conflict.
+  (func (export "_malloc") (result i32) (i32.const 11))
+  (func (export "__malloc") (result i32) (i32.const 12))
+
+  ;; Test that names are case-sensitive.
+  (func (export "a") (result i32) (i32.const 13))
+  (func (export "A") (result i32) (i32.const 14))
+
+  ;; Test that UTF-8 BOM code points can appear in identifiers.
+  (func (export "\u{feff}") (result i32) (i32.const 15))
+
+  ;; Test that Unicode normalization is not applied. These function names
+  ;; contain different codepoints which normalize to the same thing under
+  ;; NFC or NFD.
+  (func (export "\u{c5}") (result i32) (i32.const 16))
+  (func (export "A\u{30a}") (result i32) (i32.const 17))
+  (func (export "\u{212b}") (result i32) (i32.const 18))
+
+  ;; Test that Unicode compatibility normalization is not applied. These
+  ;; function names contain different codepoints which normalize to the
+  ;; same thing under NFKC or NFKD.
+  (func (export "\u{fb03}") (result i32) (i32.const 19))
+  (func (export "f\u{fb01}") (result i32) (i32.const 20))
+  (func (export "ffi") (result i32) (i32.const 21))
+
+  ;; Test the C0 control codes.
+  (func (export "\\00\\01\\02\\03\\04\\05\\06\\07\\08\\09\\0a\\0b\\0c\\0d\\0e\\0f") (result i32) (i32.const 22))
+  (func (export "\\10\\11\\12\\13\\14\\15\\16\\17\\18\\19\\1a\\1b\\1c\\1d\\1e\\1f") (result i32) (i32.const 23))
+  ;; Test miscellaneous control codes.
+  (func (export " \\7f") (result i32) (i32.const 24))
+  ;; Test the C1 control codes.
+  (func (export "\\c2\\80\\c2\\81\\c2\\82\\c2\\83\\c2\\84\\c2\\85\\c2\\86\\c2\\87\\c2\\88\\c2\\89\\c2\\8a\\c2\\8b\\c2\\8c\\c2\\8d\\c2\\8e\\c2\\8f") (result i32) (i32.const 25))
+  (func (export "\\c2\\90\\c2\\91\\c2\\92\\c2\\93\\c2\\94\\c2\\95\\c2\\96\\c2\\97\\c2\\98\\c2\\99\\c2\\9a\\c2\\9b\\c2\\9c\\c2\\9d\\c2\\9e\\c2\\9f") (result i32) (i32.const 26))
+  ;; Test the Unicode Specials.
+  (func (export "\\ef\\bf\\b0\\ef\\bf\\b1\\ef\\bf\\b2\\ef\\bf\\b3\\ef\\bf\\b4\\ef\\bf\\b5\\ef\\bf\\b6\\ef\\bf\\b7") (result i32) (i32.const 27))
+  (func (export "\\ef\\bf\\b8\\ef\\bf\\b9\\ef\\bf\\ba\\ef\\bf\\bb\\ef\\bf\\bc\\ef\\bf\\bd\\ef\\bf\\be\\ef\\bf\\bf") (result i32) (i32.const 28))
+
+  ;; Test that the control pictures are distinct from the control codes they
+  ;; depict. These correspond to the C0 and miscellaneous control code tests
+  ;; above.
+  (func (export "\u{2400}\u{2401}\u{2402}\u{2403}\u{2404}\u{2405}\u{2406}\u{2407}\u{2408}\u{2409}\u{240a}\u{240b}\u{240c}\u{240d}\u{240e}\u{240f}") (result i32) (i32.const 29))
+  (func (export "\u{2410}\u{2411}\u{2412}\u{2413}\u{2414}\u{2415}\u{2416}\u{2417}\u{2418}\u{2419}\u{241a}\u{241b}\u{241c}\u{241d}\u{241e}\u{241f}") (result i32) (i32.const 30))
+  (func (export "\u{2420}\u{2421}") (result i32) (i32.const 31))
+
+  ;; Test the Unicode Specials in non-escaped form (excluding U+FFFE and
+  ;; U+FFFF, so that generic tools don't detect this file as non-UTF-8).
+  (func (export "\u{fff0}\u{fff1}\u{fff2}\u{fff3}\u{fff4}\u{fff5}\u{fff6}\u{fff7}\u{fff8}\u{fff9}\u{fffa}\u{fffb}\u{fffc}\u{fffd}") (result i32) (i32.const 32))
+
+  ;; Test a bare ZWJ code point.
+  (func (export "\u{200d}") (result i32) (i32.const 33))
+  ;; Test a bare ZWNJ code point.
+  (func (export "\u{200c}") (result i32) (i32.const 34))
+
+  ;; Test various bare joiner code points.
+  (func (export "\u{34f}") (result i32) (i32.const 35))
+  (func (export "\u{2060}") (result i32) (i32.const 36))
+  (func (export "\u{2d7f}") (result i32) (i32.const 37))
+  (func (export "\u{1107f}") (result i32) (i32.const 38))
+  (func (export "\u{180e}") (result i32) (i32.const 39))
+
+  ;; Test various interesting code points: reverse BOM, zero-width space,
+  ;; no-break space, soft hyphen, word joiner, ogham space mark,
+  ;; right-to-left override, left-to-right override.
+  (func (export "\u{ffef}\u{200b}\u{a0}\u{ad}\u{2060}\u{1680}\u{202e}\u{202d}") (result i32) (i32.const 40))
+
+  ;; Test more interesting code points: left-to-right mark, right-to-left mark,
+  ;; non-breaking hyphen, line separator, paragraph separator,
+  ;; left-to-right embedding, right-to-left embedding,
+  ;; pop directional formatting, narrow no-break space, left-to-right isolate,
+  ;; right-to-left isolate, first strong isolate, pop directional isolate.
+  (func (export "\u{200e}\u{200f}\u{2011}\u{2028}\u{2029}\u{202a}\u{202b}\u{202c}\u{202f}\u{2066}\u{2067}\u{2068}\u{2069}") (result i32) (i32.const 41))
+
+  ;; Test some deprecated code points: inhibit symmetric swapping,
+  ;; activate symmetric swapping, inhibit arabic form shaping,
+  ;; activate arabic form shaping, national digit shapes, nominal digit shapes.
+  (func (export "\u{206a}\u{206b}\u{206c}\u{206d}\u{206e}\u{206f}") (result i32) (i32.const 42))
+
+  ;; Test "invisible" operator code points.
+  (func (export "\u{2061}\u{2062}\u{2063}\u{2064}") (result i32) (i32.const 43))
+
+  ;; Test that code points outside the BMP are supported.
+  (func (export "\u{10000}\u{dffff}\u{10ffff}") (result i32) (i32.const 44))
+
+  ;; Test that WebAssembly implementations cope in the presence of Zalgo.
+  (func (export "Z\u{30f}\u{346}\u{306}\u{35b}\u{34c}\u{334}\u{358}\u{35e}\u{347}\u{32b}\u{325}\u{32a}\u{353}\u{348}\u{354}\u{34e}\u{317}\u{31e}\u{33a}\u{32f}\u{331}\u{31e}\u{319}\u{331}\u{31c}\u{316}\u{320}a\u{357}\u{368}\u{30e}\u{304}\u{306}\u{357}\u{33f}\u{361}\u{35f}\u{340}\u{336}\u{341}\u{325}\u{330}\u{333}\u{32d}\u{359}\u{332}\u{331}\u{339}\u{31d}\u{34e}\u{33c}l\u{344}\u{34a}\u{31a}\u{357}\u{366}\u{344}\u{36b}\u{307}\u{341}\u{336}\u{337}\u{349}\u{329}\u{339}\u{32b}\u{31d}\u{356}\u{345}\u{319}\u{332}\u{33c}\u{347}\u{35a}\u{34d}\u{32e}\u{34e}\u{325}\u{345}\u{31e}g\u{343}\u{310}\u{305}\u{36e}\u{314}\u{310}\u{30e}\u{302}\u{30f}\u{33e}\u{34a}\u{30d}\u{34b}\u{34a}\u{367}\u{301}\u{306}\u{366}\u{35e}\u{336}\u{355}\u{354}\u{35a}\u{329}o\u{34b}\u{314}\u{350}\u{36a}\u{369}\u{321}\u{34f}\u{322}\u{327}\u{341}\u{32b}\u{319}\u{324}\u{32e}\u{356}\u{359}\u{353}\u{33a}\u{31c}\u{329}\u{33c}\u{318}\u{320}") (result i32) (i32.const 45))
+
+  ;; Test Hangul filler code points.
+  (func (export "\u{115f}\u{1160}\u{3164}\u{ffa0}") (result i32) (i32.const 46))
+
+  ;; Test variation selectors (which are also ID_Continue code points).
+  (func (export "\u{fe00}") (result i32) (i32.const 47))
+  (func (export "\u{fe04}") (result i32) (i32.const 48))
+  (func (export "\u{e0100}") (result i32) (i32.const 49))
+  (func (export "\u{e01ef}") (result i32) (i32.const 50))
+
+  ;; Test an uncombined combining code point.
+  (func (export "\u{308}") (result i32) (i32.const 51))
+
+  ;; Test that numerous different present and historical representations of the
+  ;; "newline" concept are distinct. Tests largely inspired by:
+  ;;   https://en.wikipedia.org/wiki/Newline#Representations
+  ;;   https://en.wikipedia.org/wiki/Newline#Unicode and
+  ;;   https://en.wikipedia.org/wiki/Newline#Reverse_and_partial_line_feeds
+  (func (export "\\0a") (result i32) (i32.const 52))
+  (func (export "\u{2424}") (result i32) (i32.const 53))
+  (func (export "\u{2028}") (result i32) (i32.const 54))
+  (func (export "\\0d") (result i32) (i32.const 55))
+  (func (export "\\0d\\0a") (result i32) (i32.const 56))
+  (func (export "\\0a\\0d") (result i32) (i32.const 57))
+  (func (export "\\1e") (result i32) (i32.const 58))
+  (func (export "\\0b") (result i32) (i32.const 59))
+  (func (export "\\0c") (result i32) (i32.const 60))
+  (func (export "\\c2\\85") (result i32) (i32.const 61))
+  (func (export "\u{2029}") (result i32) (i32.const 62))
+  (func (export "\u{2026}") (result i32) (i32.const 63))
+  (func (export "\u{23ce}") (result i32) (i32.const 64))
+  (func (export "\\c2\\8b") (result i32) (i32.const 65))
+  (func (export "\\c2\\8c") (result i32) (i32.const 66))
+  (func (export "\\c2\\8d") (result i32) (i32.const 67))
+  (func (export "\u{21b5}") (result i32) (i32.const 68))
+  (func (export "\u{21a9}") (result i32) (i32.const 69))
+  (func (export "\u{2324}") (result i32) (i32.const 70))
+  (func (export "\u{2936}") (result i32) (i32.const 71))
+  (func (export "\u{21b2}") (result i32) (i32.const 72))
+  (func (export "\u{2ba8}") (result i32) (i32.const 73))
+  (func (export "\u{2bb0}") (result i32) (i32.const 74))
+
+  ;; Test that non-characters are not replaced by the replacement character.
+  (func (export "\u{fffd}") (result i32) (i32.const 75))
+  (func (export "\\ef\\b7\\90") (result i32) (i32.const 76))
+  (func (export "\\ef\\b7\\91") (result i32) (i32.const 77))
+  (func (export "\\ef\\b7\\92") (result i32) (i32.const 78))
+  (func (export "\\ef\\b7\\93") (result i32) (i32.const 79))
+  (func (export "\\ef\\b7\\94") (result i32) (i32.const 80))
+  (func (export "\\ef\\b7\\95") (result i32) (i32.const 81))
+  (func (export "\\ef\\b7\\96") (result i32) (i32.const 82))
+  (func (export "\\ef\\b7\\97") (result i32) (i32.const 83))
+  (func (export "\\ef\\b7\\98") (result i32) (i32.const 84))
+  (func (export "\\ef\\b7\\99") (result i32) (i32.const 85))
+  (func (export "\\ef\\b7\\9a") (result i32) (i32.const 86))
+  (func (export "\\ef\\b7\\9b") (result i32) (i32.const 87))
+  (func (export "\\ef\\b7\\9c") (result i32) (i32.const 88))
+  (func (export "\\ef\\b7\\9d") (result i32) (i32.const 89))
+  (func (export "\\ef\\b7\\9e") (result i32) (i32.const 90))
+  (func (export "\\ef\\b7\\9f") (result i32) (i32.const 91))
+  (func (export "\\ef\\b7\\a0") (result i32) (i32.const 92))
+  (func (export "\\ef\\b7\\a1") (result i32) (i32.const 93))
+  (func (export "\\ef\\b7\\a2") (result i32) (i32.const 94))
+  (func (export "\\ef\\b7\\a3") (result i32) (i32.const 95))
+  (func (export "\\ef\\b7\\a4") (result i32) (i32.const 96))
+  (func (export "\\ef\\b7\\a5") (result i32) (i32.const 97))
+  (func (export "\\ef\\b7\\a6") (result i32) (i32.const 98))
+  (func (export "\\ef\\b7\\a7") (result i32) (i32.const 99))
+  (func (export "\\ef\\b7\\a8") (result i32) (i32.const 100))
+  (func (export "\\ef\\b7\\a9") (result i32) (i32.const 101))
+  (func (export "\\ef\\b7\\aa") (result i32) (i32.const 102))
+  (func (export "\\ef\\b7\\ab") (result i32) (i32.const 103))
+  (func (export "\\ef\\b7\\ac") (result i32) (i32.const 104))
+  (func (export "\\ef\\b7\\ad") (result i32) (i32.const 105))
+  (func (export "\\ef\\b7\\ae") (result i32) (i32.const 106))
+  (func (export "\\ef\\b7\\af") (result i32) (i32.const 107))
+  (func (export "\\ef\\bf\\be") (result i32) (i32.const 108))
+  (func (export "\\ef\\bf\\bf") (result i32) (i32.const 109))
+  (func (export "\\f0\\9f\\bf\\be") (result i32) (i32.const 110))
+  (func (export "\\f0\\9f\\bf\\bf") (result i32) (i32.const 111))
+  (func (export "\\f0\\af\\bf\\be") (result i32) (i32.const 112))
+  (func (export "\\f0\\af\\bf\\bf") (result i32) (i32.const 113))
+  (func (export "\\f0\\bf\\bf\\be") (result i32) (i32.const 114))
+  (func (export "\\f0\\bf\\bf\\bf") (result i32) (i32.const 115))
+  (func (export "\\f1\\8f\\bf\\be") (result i32) (i32.const 116))
+  (func (export "\\f1\\8f\\bf\\bf") (result i32) (i32.const 117))
+  (func (export "\\f1\\9f\\bf\\be") (result i32) (i32.const 118))
+  (func (export "\\f1\\9f\\bf\\bf") (result i32) (i32.const 119))
+  (func (export "\\f1\\af\\bf\\be") (result i32) (i32.const 120))
+  (func (export "\\f1\\af\\bf\\bf") (result i32) (i32.const 121))
+  (func (export "\\f1\\bf\\bf\\be") (result i32) (i32.const 122))
+  (func (export "\\f1\\bf\\bf\\bf") (result i32) (i32.const 123))
+  (func (export "\\f2\\8f\\bf\\be") (result i32) (i32.const 124))
+  (func (export "\\f2\\8f\\bf\\bf") (result i32) (i32.const 125))
+  (func (export "\\f2\\9f\\bf\\be") (result i32) (i32.const 126))
+  (func (export "\\f2\\9f\\bf\\bf") (result i32) (i32.const 127))
+  (func (export "\\f2\\af\\bf\\be") (result i32) (i32.const 128))
+  (func (export "\\f2\\af\\bf\\bf") (result i32) (i32.const 129))
+  (func (export "\\f2\\bf\\bf\\be") (result i32) (i32.const 130))
+  (func (export "\\f2\\bf\\bf\\bf") (result i32) (i32.const 131))
+  (func (export "\\f3\\8f\\bf\\be") (result i32) (i32.const 132))
+  (func (export "\\f3\\8f\\bf\\bf") (result i32) (i32.const 133))
+  (func (export "\\f3\\9f\\bf\\be") (result i32) (i32.const 134))
+  (func (export "\\f3\\9f\\bf\\bf") (result i32) (i32.const 135))
+  (func (export "\\f3\\af\\bf\\be") (result i32) (i32.const 136))
+  (func (export "\\f3\\af\\bf\\bf") (result i32) (i32.const 137))
+  (func (export "\\f3\\bf\\bf\\be") (result i32) (i32.const 138))
+  (func (export "\\f3\\bf\\bf\\bf") (result i32) (i32.const 139))
+  (func (export "\\f4\\8f\\bf\\be") (result i32) (i32.const 140))
+  (func (export "\\f4\\8f\\bf\\bf") (result i32) (i32.const 141))
+
+  ;; Test an interrobang with combining diacritical marks above.
+  ;; https://xkcd.com/1209/
+  (func (export "\u{308}\u{203d}\u{308}\u{309}") (result i32) (i32.const 142))
+
+  ;; Test that RLM/LRM don't change the logical byte order.
+  (func (export "abc") (result i32) (i32.const 143))
+  (func (export "\u{202d}abc") (result i32) (i32.const 144))
+  (func (export "\u{202e}cba") (result i32) (i32.const 145))
+  (func (export "\u{202d}abc\u{202e}") (result i32) (i32.const 146))
+  (func (export "\u{202e}cba\u{202d}") (result i32) (i32.const 147))
+
+  ;; Test that Unicode font variations are preserved.
+  (func (export "\u{1d468}") (result i32) (i32.const 148))
+  (func (export "\u{1d434}") (result i32) (i32.const 149))
+  (func (export "\u{1d608}") (result i32) (i32.const 150))
+  (func (export "\u{1d63c}") (result i32) (i32.const 151))
+  (func (export "\u{1d400}") (result i32) (i32.const 152))
+  (func (export "\u{1d4d0}") (result i32) (i32.const 153))
+  (func (export "\u{1d56c}") (result i32) (i32.const 154))
+  (func (export "\u{1d5d4}") (result i32) (i32.const 155))
+  (func (export "\u{1d49c}") (result i32) (i32.const 156))
+  (func (export "\u{1d504}") (result i32) (i32.const 157))
+  (func (export "\u{1d538}") (result i32) (i32.const 158))
+  (func (export "\u{1d5a0}") (result i32) (i32.const 159))
+  (func (export "\u{1d670}") (result i32) (i32.const 160))
+  (func (export "\u{1d00}") (result i32) (i32.const 161))
+
+  ;; Test that various additional letter variations are preserved.
+  ;; (U+0040, U+0061, U+0041, U+00C5, U+0041 U+030A, U+212B, and the font
+  ;; variations are covered above.)
+  (func (export "\u{1d2c}") (result i32) (i32.const 162))
+  (func (export "\u{24b6}") (result i32) (i32.const 163))
+  (func (export "\u{ff21}") (result i32) (i32.const 164))
+  (func (export "\u{1f110}") (result i32) (i32.const 165))
+  (func (export "\u{1f130}") (result i32) (i32.const 166))
+  (func (export "\u{e0041}") (result i32) (i32.const 167))
+  (func (export "U+0041") (result i32) (i32.const 168))
+  (func (export "A\u{200b}") (result i32) (i32.const 169))
+  (func (export "\u{410}") (result i32) (i32.const 170))
+  (func (export "\u{a656}") (result i32) (i32.const 171))
+  (func (export "\u{2dfc}") (result i32) (i32.const 172))
+  (func (export "\u{2df6}") (result i32) (i32.const 173))
+  (func (export "\u{2c6f}") (result i32) (i32.const 174))
+  (func (export "\u{1f150}") (result i32) (i32.const 175))
+  (func (export "\u{1f170}") (result i32) (i32.const 176))
+  (func (export "\u{2c2d}") (result i32) (i32.const 177))
+  (func (export "\u{10402}") (result i32) (i32.const 178))
+  (func (export "\u{10408}") (result i32) (i32.const 179))
+  (func (export "\u{104b0}") (result i32) (i32.const 180))
+  (func (export "\u{c0}") (result i32) (i32.const 181))
+  (func (export "\u{c1}") (result i32) (i32.const 182))
+  (func (export "\u{c2}") (result i32) (i32.const 183))
+  (func (export "\u{c3}") (result i32) (i32.const 184))
+  (func (export "\u{c4}") (result i32) (i32.const 185))
+  (func (export "\u{100}") (result i32) (i32.const 186))
+  (func (export "\u{102}") (result i32) (i32.const 187))
+  (func (export "\u{104}") (result i32) (i32.const 188))
+  (func (export "\u{1cd}") (result i32) (i32.const 189))
+  (func (export "\u{1de}") (result i32) (i32.const 190))
+  (func (export "\u{1e0}") (result i32) (i32.const 191))
+  (func (export "\u{1fa}") (result i32) (i32.const 192))
+  (func (export "\u{200}") (result i32) (i32.const 193))
+  (func (export "\u{202}") (result i32) (i32.const 194))
+  (func (export "\u{226}") (result i32) (i32.const 195))
+  (func (export "\u{23a}") (result i32) (i32.const 196))
+  (func (export "\u{4d0}") (result i32) (i32.const 197))
+  (func (export "\u{4d2}") (result i32) (i32.const 198))
+  (func (export "\u{7ca}") (result i32) (i32.const 199))
+  (func (export "\u{821}") (result i32) (i32.const 200))
+  (func (export "\u{822}") (result i32) (i32.const 201))
+  (func (export "\u{823}") (result i32) (i32.const 202))
+  (func (export "\u{824}") (result i32) (i32.const 203))
+  (func (export "\u{825}") (result i32) (i32.const 204))
+  (func (export "\u{904}") (result i32) (i32.const 205))
+  (func (export "\u{905}") (result i32) (i32.const 206))
+  (func (export "\u{972}") (result i32) (i32.const 207))
+  (func (export "\u{985}") (result i32) (i32.const 208))
+  (func (export "\u{a05}") (result i32) (i32.const 209))
+  (func (export "\u{a85}") (result i32) (i32.const 210))
+  (func (export "\u{b05}") (result i32) (i32.const 211))
+  (func (export "\u{b85}") (result i32) (i32.const 212))
+  (func (export "\u{c05}") (result i32) (i32.const 213))
+  (func (export "\u{c85}") (result i32) (i32.const 214))
+  (func (export "\u{d05}") (result i32) (i32.const 215))
+  (func (export "\u{e30}") (result i32) (i32.const 216))
+  (func (export "\u{eb0}") (result i32) (i32.const 217))
+  (func (export "\u{f01}") (result i32) (i32.const 218))
+  (func (export "\u{f68}") (result i32) (i32.const 219))
+  (func (export "\u{fb8}") (result i32) (i32.const 220))
+  (func (export "\u{1021}") (result i32) (i32.const 221))
+  (func (export "\u{1022}") (result i32) (i32.const 222))
+  (func (export "\u{109c}") (result i32) (i32.const 223))
+  (func (export "\u{1161}") (result i32) (i32.const 224))
+  (func (export "\u{12a0}") (result i32) (i32.const 225))
+  (func (export "\u{12d0}") (result i32) (i32.const 226))
+  (func (export "\u{13a0}") (result i32) (i32.const 227))
+  (func (export "\u{140a}") (result i32) (i32.const 228))
+  (func (export "\u{15b3}") (result i32) (i32.const 229))
+  (func (export "\u{16a8}") (result i32) (i32.const 230))
+  (func (export "\u{16aa}") (result i32) (i32.const 231))
+  (func (export "\u{16c6}") (result i32) (i32.const 232))
+  (func (export "\u{1700}") (result i32) (i32.const 233))
+  (func (export "\u{1720}") (result i32) (i32.const 234))
+  (func (export "\u{1740}") (result i32) (i32.const 235))
+  (func (export "\u{1760}") (result i32) (i32.const 236))
+  (func (export "\u{1820}") (result i32) (i32.const 237))
+  (func (export "\u{1887}") (result i32) (i32.const 238))
+  (func (export "\u{1920}") (result i32) (i32.const 239))
+  (func (export "\u{1963}") (result i32) (i32.const 240))
+  (func (export "\u{1a15}") (result i32) (i32.const 241))
+  (func (export "\u{1a4b}") (result i32) (i32.const 242))
+  (func (export "\u{1a61}") (result i32) (i32.const 243))
+  (func (export "\u{1b83}") (result i32) (i32.const 244))
+  (func (export "\u{1bc0}") (result i32) (i32.const 245))
+  (func (export "\u{1bc1}") (result i32) (i32.const 246))
+  (func (export "\u{1c23}") (result i32) (i32.const 247))
+  (func (export "\u{1e00}") (result i32) (i32.const 248))
+  (func (export "\u{1ea0}") (result i32) (i32.const 249))
+  (func (export "\u{1ea2}") (result i32) (i32.const 250))
+  (func (export "\u{1ea4}") (result i32) (i32.const 251))
+  (func (export "\u{1ea6}") (result i32) (i32.const 252))
+  (func (export "\u{1ea8}") (result i32) (i32.const 253))
+  (func (export "\u{1eaa}") (result i32) (i32.const 254))
+  (func (export "\u{1eac}") (result i32) (i32.const 255))
+  (func (export "\u{1eae}") (result i32) (i32.const 256))
+  (func (export "\u{1eb0}") (result i32) (i32.const 257))
+  (func (export "\u{1eb2}") (result i32) (i32.const 258))
+  (func (export "\u{1eb4}") (result i32) (i32.const 259))
+  (func (export "\u{1eb6}") (result i32) (i32.const 260))
+  (func (export "\u{3042}") (result i32) (i32.const 261))
+  (func (export "\u{30a2}") (result i32) (i32.const 262))
+  (func (export "\u{311a}") (result i32) (i32.const 263))
+  (func (export "\u{314f}") (result i32) (i32.const 264))
+  (func (export "\u{320e}") (result i32) (i32.const 265))
+  (func (export "\u{320f}") (result i32) (i32.const 266))
+  (func (export "\u{3210}") (result i32) (i32.const 267))
+  (func (export "\u{3211}") (result i32) (i32.const 268))
+  (func (export "\u{3212}") (result i32) (i32.const 269))
+  (func (export "\u{3213}") (result i32) (i32.const 270))
+  (func (export "\u{3214}") (result i32) (i32.const 271))
+  (func (export "\u{3215}") (result i32) (i32.const 272))
+  (func (export "\u{3216}") (result i32) (i32.const 273))
+  (func (export "\u{3217}") (result i32) (i32.const 274))
+  (func (export "\u{3218}") (result i32) (i32.const 275))
+  (func (export "\u{3219}") (result i32) (i32.const 276))
+  (func (export "\u{321a}") (result i32) (i32.const 277))
+  (func (export "\u{321b}") (result i32) (i32.const 278))
+  (func (export "\u{326e}") (result i32) (i32.const 279))
+  (func (export "\u{326f}") (result i32) (i32.const 280))
+  (func (export "\u{3270}") (result i32) (i32.const 281))
+  (func (export "\u{3271}") (result i32) (i32.const 282))
+  (func (export "\u{3272}") (result i32) (i32.const 283))
+  (func (export "\u{3273}") (result i32) (i32.const 284))
+  (func (export "\u{3274}") (result i32) (i32.const 285))
+  (func (export "\u{3275}") (result i32) (i32.const 286))
+  (func (export "\u{3276}") (result i32) (i32.const 287))
+  (func (export "\u{3277}") (result i32) (i32.const 288))
+  (func (export "\u{3278}") (result i32) (i32.const 289))
+  (func (export "\u{3279}") (result i32) (i32.const 290))
+  (func (export "\u{327a}") (result i32) (i32.const 291))
+  (func (export "\u{327b}") (result i32) (i32.const 292))
+  (func (export "\u{32d0}") (result i32) (i32.const 293))
+  (func (export "\u{a00a}") (result i32) (i32.const 294))
+  (func (export "\u{a4ee}") (result i32) (i32.const 295))
+  (func (export "\u{a549}") (result i32) (i32.const 296))
+  (func (export "\u{a6a0}") (result i32) (i32.const 297))
+  (func (export "\u{a800}") (result i32) (i32.const 298))
+  (func (export "\u{a823}") (result i32) (i32.const 299))
+  (func (export "\u{a85d}") (result i32) (i32.const 300))
+  (func (export "\u{a882}") (result i32) (i32.const 301))
+  (func (export "\u{a8ea}") (result i32) (i32.const 302))
+  (func (export "\u{a922}") (result i32) (i32.const 303))
+  (func (export "\u{a946}") (result i32) (i32.const 304))
+  (func (export "\u{a984}") (result i32) (i32.const 305))
+  (func (export "\u{aa00}") (result i32) (i32.const 306))
+  (func (export "\u{ff71}") (result i32) (i32.const 307))
+  (func (export "\u{ffc2}") (result i32) (i32.const 308))
+  (func (export "\u{10000}") (result i32) (i32.const 309))
+  (func (export "\u{10280}") (result i32) (i32.const 310))
+  (func (export "\u{102a0}") (result i32) (i32.const 311))
+  (func (export "\u{10300}") (result i32) (i32.const 312))
+  (func (export "\u{103a0}") (result i32) (i32.const 313))
+  (func (export "\u{10496}") (result i32) (i32.const 314))
+  (func (export "\u{10500}") (result i32) (i32.const 315))
+  (func (export "\u{10740}") (result i32) (i32.const 316))
+  (func (export "\u{10800}") (result i32) (i32.const 317))
+  (func (export "\u{10920}") (result i32) (i32.const 318))
+  (func (export "\u{10980}") (result i32) (i32.const 319))
+  (func (export "\u{109a0}") (result i32) (i32.const 320))
+  (func (export "\u{10a00}") (result i32) (i32.const 321))
+  (func (export "\u{10b00}") (result i32) (i32.const 322))
+  (func (export "\u{10c00}") (result i32) (i32.const 323))
+  (func (export "\u{10c01}") (result i32) (i32.const 324))
+  (func (export "\u{10c80}") (result i32) (i32.const 325))
+  (func (export "\u{11005}") (result i32) (i32.const 326))
+  (func (export "\u{11083}") (result i32) (i32.const 327))
+  (func (export "\u{11127}") (result i32) (i32.const 328))
+  (func (export "\u{11150}") (result i32) (i32.const 329))
+  (func (export "\u{11183}") (result i32) (i32.const 330))
+  (func (export "\u{11200}") (result i32) (i32.const 331))
+  (func (export "\u{11280}") (result i32) (i32.const 332))
+  (func (export "\u{112b0}") (result i32) (i32.const 333))
+  (func (export "\u{11305}") (result i32) (i32.const 334))
+  (func (export "\u{11370}") (result i32) (i32.const 335))
+  (func (export "\u{11400}") (result i32) (i32.const 336))
+  (func (export "\u{11481}") (result i32) (i32.const 337))
+  (func (export "\u{11580}") (result i32) (i32.const 338))
+  (func (export "\u{11600}") (result i32) (i32.const 339))
+  (func (export "\u{11680}") (result i32) (i32.const 340))
+  (func (export "\u{11712}") (result i32) (i32.const 341))
+  (func (export "\u{11720}") (result i32) (i32.const 342))
+  (func (export "\u{118a1}") (result i32) (i32.const 343))
+  (func (export "\u{11ad5}") (result i32) (i32.const 344))
+  (func (export "\u{11c00}") (result i32) (i32.const 345))
+  (func (export "\u{11c8f}") (result i32) (i32.const 346))
+  (func (export "\u{11caf}") (result i32) (i32.const 347))
+  (func (export "\u{12000}") (result i32) (i32.const 348))
+  (func (export "\u{169d5}") (result i32) (i32.const 349))
+  (func (export "\u{16a46}") (result i32) (i32.const 350))
+  (func (export "\u{16ae7}") (result i32) (i32.const 351))
+  (func (export "\u{16f54}") (result i32) (i32.const 352))
+  (func (export "\u{1bc41}") (result i32) (i32.const 353))
+  (func (export "\u{1bc64}") (result i32) (i32.const 354))
+  (func (export "\u{1e823}") (result i32) (i32.const 355))
+  (func (export "\u{1f1e6}") (result i32) (i32.const 356))
+  (func (export "\u{2c6d}") (result i32) (i32.const 357))
+  (func (export "\u{39b}") (result i32) (i32.const 358))
+  (func (export "\u{2c70}") (result i32) (i32.const 359))
+  (func (export "\u{aa}") (result i32) (i32.const 360))
+  (func (export "\u{2200}") (result i32) (i32.const 361))
+  (func (export "\u{20b3}") (result i32) (i32.const 362))
+  (func (export "\u{10900}") (result i32) (i32.const 363))
+  (func (export "\u{2c80}") (result i32) (i32.const 364))
+  (func (export "\u{10330}") (result i32) (i32.const 365))
+  (func (export "\u{386}") (result i32) (i32.const 366))
+  (func (export "\u{391}") (result i32) (i32.const 367))
+  (func (export "\u{1f08}") (result i32) (i32.const 368))
+  (func (export "\u{1f09}") (result i32) (i32.const 369))
+  (func (export "\u{1f0a}") (result i32) (i32.const 370))
+  (func (export "\u{1f0b}") (result i32) (i32.const 371))
+  (func (export "\u{1f0c}") (result i32) (i32.const 372))
+  (func (export "\u{1f0d}") (result i32) (i32.const 373))
+  (func (export "\u{1f0e}") (result i32) (i32.const 374))
+  (func (export "\u{1f0f}") (result i32) (i32.const 375))
+  (func (export "\u{1f88}") (result i32) (i32.const 376))
+  (func (export "\u{1f89}") (result i32) (i32.const 377))
+  (func (export "\u{1f8a}") (result i32) (i32.const 378))
+  (func (export "\u{1f8b}") (result i32) (i32.const 379))
+  (func (export "\u{1f8c}") (result i32) (i32.const 380))
+  (func (export "\u{1f8d}") (result i32) (i32.const 381))
+  (func (export "\u{1f8e}") (result i32) (i32.const 382))
+  (func (export "\u{1f8f}") (result i32) (i32.const 383))
+  (func (export "\u{1fb8}") (result i32) (i32.const 384))
+  (func (export "\u{1fb9}") (result i32) (i32.const 385))
+  (func (export "\u{1fba}") (result i32) (i32.const 386))
+  (func (export "\u{1fbb}") (result i32) (i32.const 387))
+  (func (export "\u{1fbc}") (result i32) (i32.const 388))
+  (func (export "\u{1d6a8}") (result i32) (i32.const 389))
+  (func (export "\u{1d6e2}") (result i32) (i32.const 390))
+  (func (export "\u{1d71c}") (result i32) (i32.const 391))
+  (func (export "\u{1d756}") (result i32) (i32.const 392))
+  (func (export "\u{1d790}") (result i32) (i32.const 393))
+  (func (export "\u{2376}") (result i32) (i32.const 394))
+  (func (export "\u{237a}") (result i32) (i32.const 395))
+  (func (export "\u{2a5c}") (result i32) (i32.const 396))
+  (func (export "\u{15c5}") (result i32) (i32.const 397))
+  (func (export "\u{13aa}") (result i32) (i32.const 398))
+
+  ;; Test unmatched "closing" and "opening" code points.
+  (func (export ")\u{2fa}\u{2fc}\u{145cf}\u{1d174}\u{1d176}\u{1d178}\u{1d17a}\u{207e}\u{208e}\u{2769}\u{276b}\u{27ef}\u{fd3f}\u{fe36}\u{fe5a}\u{ff09}\u{ff60}\u{e0029}\u{2773}\u{2775}\u{27e7}\u{27e9}\u{27eb}\u{27ed}\u{2988}\u{298a}\u{2996}\u{2e23}\u{2e25}\u{fe18}\u{fe38}\u{fe3a}\u{fe3c}\u{fe3e}\u{fe40}\u{fe42}\u{fe44}\u{fe48}\u{fe5c}\u{fe5e}\u{ff3d}\u{ff5d}\u{ff63}\u{e005d}\u{e007d}\u{bb}\u{2019}\u{201d}\u{203a}\u{276f}") (result i32) (i32.const 399))
+  (func (export "(\u{2f9}\u{2fb}\u{145ce}\u{1d173}\u{1d175}\u{1d177}\u{1d179}\u{207d}\u{208d}\u{2768}\u{276a}\u{27ee}\u{fd3e}\u{fe35}\u{fe59}\u{ff08}\u{ff5f}\u{e0028}\u{2772}\u{2774}\u{27e6}\u{27e8}\u{27ea}\u{27ec}\u{2987}\u{2989}\u{2995}\u{2e22}\u{2e24}\u{fe17}\u{fe37}\u{fe39}\u{fe3b}\u{fe3d}\u{fe3f}\u{fe41}\u{fe43}\u{fe47}\u{fe5b}\u{fe5d}\u{ff3b}\u{ff5b}\u{ff62}\u{e005b}\u{e007b}\u{ab}\u{2018}\u{201c}\u{2039}\u{276e}") (result i32) (i32.const 400))
+  (func (export "\u{1da8b}\u{1daa4}") (result i32) (i32.const 401))
+  (func (export "\u{1da8b}") (result i32) (i32.const 402))
+
+  ;; Test that Unicode fraction normalization is not applied.
+  (func (export "\u{bd}") (result i32) (i32.const 403))
+  (func (export "1\u{2044}2") (result i32) (i32.const 404))
+  (func (export "1/2") (result i32) (i32.const 405))
+  (func (export "\u{b73}") (result i32) (i32.const 406))
+  (func (export "\u{d74}") (result i32) (i32.const 407))
+  (func (export "\u{2cfd}") (result i32) (i32.const 408))
+  (func (export "\u{a831}") (result i32) (i32.const 409))
+  (func (export "\u{10141}") (result i32) (i32.const 410))
+  (func (export "\u{10175}") (result i32) (i32.const 411))
+  (func (export "\u{10176}") (result i32) (i32.const 412))
+  (func (export "\u{109bd}") (result i32) (i32.const 413))
+  (func (export "\u{10e7b}") (result i32) (i32.const 414))
+
+  ;; Test a full-width quote.
+  (func (export "\u{ff02}") (result i32) (i32.const 415))
+
+  ;; Test that different present and historical representations of the "delete"
+  ;; concept are distinct.
+  (func (export "\\7f") (result i32) (i32.const 416))
+  (func (export "\\08") (result i32) (i32.const 417))
+  (func (export "\u{232b}") (result i32) (i32.const 418))
+  (func (export "\u{2326}") (result i32) (i32.const 419))
+  (func (export "\u{2408}") (result i32) (i32.const 420))
+  (func (export "\u{2421}") (result i32) (i32.const 421))
+  (func (export "\u{1dfb}") (result i32) (i32.const 422))
+  (func (export "\\0f") (result i32) (i32.const 423))
+  (func (export "\u{2190}") (result i32) (i32.const 424))
+  (func (export "\u{2327}") (result i32) (i32.const 425))
+  (func (export "\u{2352}") (result i32) (i32.const 426))
+  (func (export "\u{2354}") (result i32) (i32.const 427))
+  (func (export "\u{2362}") (result i32) (i32.const 428))
+  (func (export "\u{236b}") (result i32) (i32.const 429))
+
+  ;; Test that different representations of the "substitute" concept are
+  ;; distinct. (U+FFFD is covered above.)
+  (func (export "\\1a") (result i32) (i32.const 430))
+  (func (export "\u{2426}") (result i32) (i32.const 431))
+  (func (export "\u{241a}") (result i32) (i32.const 432))
+  (func (export "\u{fffc}") (result i32) (i32.const 433))
+  (func (export "?") (result i32) (i32.const 434))
+  (func (export "\u{bf}") (result i32) (i32.const 435))
+  (func (export "\u{1945}") (result i32) (i32.const 436))
+  (func (export "\u{37e}") (result i32) (i32.const 437))
+  (func (export "\u{55e}") (result i32) (i32.const 438))
+  (func (export "\u{61f}") (result i32) (i32.const 439))
+  (func (export "\u{1367}") (result i32) (i32.const 440))
+  (func (export "\u{2047}") (result i32) (i32.const 441))
+  (func (export "\u{2370}") (result i32) (i32.const 442))
+  (func (export "\u{2753}") (result i32) (i32.const 443))
+  (func (export "\u{2754}") (result i32) (i32.const 444))
+  (func (export "\u{2cfa}") (result i32) (i32.const 445))
+  (func (export "\u{2cfb}") (result i32) (i32.const 446))
+  (func (export "\u{2e2e}") (result i32) (i32.const 447))
+  (func (export "\u{3244}") (result i32) (i32.const 448))
+  (func (export "\u{a60f}") (result i32) (i32.const 449))
+  (func (export "\u{a6f7}") (result i32) (i32.const 450))
+  (func (export "\u{fe16}") (result i32) (i32.const 451))
+  (func (export "\u{fe56}") (result i32) (i32.const 452))
+  (func (export "\u{ff1f}") (result i32) (i32.const 453))
+  (func (export "\u{11143}") (result i32) (i32.const 454))
+  (func (export "\u{1e95f}") (result i32) (i32.const 455))
+  (func (export "\u{e003f}") (result i32) (i32.const 456))
+  (func (export "\u{16844}") (result i32) (i32.const 457))
+  (func (export "\u{2bd1}") (result i32) (i32.const 458))
+
+  ;; Test that different present and historical representations of the
+  ;; "paragraph" concept are distinct. (U+2029 is covered above).
+  (func (export "\u{b6}") (result i32) (i32.const 459))
+  (func (export "\u{204b}") (result i32) (i32.const 460))
+  (func (export "\u{700}") (result i32) (i32.const 461))
+  (func (export "\u{10fb}") (result i32) (i32.const 462))
+  (func (export "\u{1368}") (result i32) (i32.const 463))
+  (func (export "\u{3037}") (result i32) (i32.const 464))
+  (func (export "\u{2761}") (result i32) (i32.const 465))
+  (func (export "\u{2e0f}") (result i32) (i32.const 466))
+  (func (export "\u{2e10}") (result i32) (i32.const 467))
+  (func (export "\u{2e11}") (result i32) (i32.const 468))
+  (func (export "\u{2e0e}") (result i32) (i32.const 469))
+  (func (export "\\14") (result i32) (i32.const 470)) ;; \u{b6} in CP437
+  (func (export "\u{2619}") (result i32) (i32.const 471))
+  (func (export "\u{2e3f}") (result i32) (i32.const 472))
+  (func (export "\u{3007}") (result i32) (i32.const 473))
+  (func (export "\u{e5b}") (result i32) (i32.const 474))
+
+  ;; Test an unusual character.
+  (func (export "\u{a66e}") (result i32) (i32.const 475))
+
+  ;; Test the three characters whose normalization forms under NFC, NFD, NFKC,
+  ;; and NFKD are all different.
+  ;; http://unicode.org/faq/normalization.html#6
+  (func (export "\u{3d3}") (result i32) (i32.const 476))
+  (func (export "\u{3d4}") (result i32) (i32.const 477))
+  (func (export "\u{1e9b}") (result i32) (i32.const 478))
+)`);
+
+// ./test/core/names.wast:615
+assert_return(() => invoke($2, ``, []), [value("i32", 0)]);
+
+// ./test/core/names.wast:616
+assert_return(() => invoke($2, `0`, []), [value("i32", 1)]);
+
+// ./test/core/names.wast:617
+assert_return(() => invoke($2, `-0`, []), [value("i32", 2)]);
+
+// ./test/core/names.wast:618
+assert_return(() => invoke($2, `_`, []), [value("i32", 3)]);
+
+// ./test/core/names.wast:619
+assert_return(() => invoke($2, `$$`, []), [value("i32", 4)]);
+
+// ./test/core/names.wast:620
+assert_return(() => invoke($2, `@`, []), [value("i32", 5)]);
+
+// ./test/core/names.wast:621
+assert_return(() => invoke($2, `~!@#$$%^&*()_+\`-={}|[]\\:";'<>?,./ `, []), [value("i32", 6)]);
+
+// ./test/core/names.wast:622
+assert_return(() => invoke($2, `NaN`, []), [value("i32", 7)]);
+
+// ./test/core/names.wast:623
+assert_return(() => invoke($2, `Infinity`, []), [value("i32", 8)]);
+
+// ./test/core/names.wast:624
+assert_return(() => invoke($2, `if`, []), [value("i32", 9)]);
+
+// ./test/core/names.wast:625
+assert_return(() => invoke($2, `malloc`, []), [value("i32", 10)]);
+
+// ./test/core/names.wast:626
+assert_return(() => invoke($2, `_malloc`, []), [value("i32", 11)]);
+
+// ./test/core/names.wast:627
+assert_return(() => invoke($2, `__malloc`, []), [value("i32", 12)]);
+
+// ./test/core/names.wast:628
+assert_return(() => invoke($2, `a`, []), [value("i32", 13)]);
+
+// ./test/core/names.wast:629
+assert_return(() => invoke($2, `A`, []), [value("i32", 14)]);
+
+// ./test/core/names.wast:630
+assert_return(() => invoke($2, `\u{feff}`, []), [value("i32", 15)]);
+
+// ./test/core/names.wast:631
+assert_return(() => invoke($2, `\u{c5}`, []), [value("i32", 16)]);
+
+// ./test/core/names.wast:632
+assert_return(() => invoke($2, `A\u{30a}`, []), [value("i32", 17)]);
+
+// ./test/core/names.wast:633
+assert_return(() => invoke($2, `\u{212b}`, []), [value("i32", 18)]);
+
+// ./test/core/names.wast:634
+assert_return(() => invoke($2, `\u{fb03}`, []), [value("i32", 19)]);
+
+// ./test/core/names.wast:635
+assert_return(() => invoke($2, `f\u{fb01}`, []), [value("i32", 20)]);
+
+// ./test/core/names.wast:636
+assert_return(() => invoke($2, `ffi`, []), [value("i32", 21)]);
+
+// ./test/core/names.wast:637
+assert_return(
+  () => invoke($2, `\x00\x01\x02\x03\x04\x05\x06\x07\x08	
+\x0b\x0c\x0d\x0e\x0f`, []),
+  [value("i32", 22)],
+);
+
+// ./test/core/names.wast:638
+assert_return(
+  () => invoke($2, `\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f`, []),
+  [value("i32", 23)],
+);
+
+// ./test/core/names.wast:639
+assert_return(() => invoke($2, ` \x7f`, []), [value("i32", 24)]);
+
+// ./test/core/names.wast:640
+assert_return(
+  () => invoke($2, `\u{80}\u{81}\u{82}\u{83}\u{84}\u{85}\u{86}\u{87}\u{88}\u{89}\u{8a}\u{8b}\u{8c}\u{8d}\u{8e}\u{8f}`, []),
+  [value("i32", 25)],
+);
+
+// ./test/core/names.wast:641
+assert_return(
+  () => invoke($2, `\u{90}\u{91}\u{92}\u{93}\u{94}\u{95}\u{96}\u{97}\u{98}\u{99}\u{9a}\u{9b}\u{9c}\u{9d}\u{9e}\u{9f}`, []),
+  [value("i32", 26)],
+);
+
+// ./test/core/names.wast:642
+assert_return(
+  () => invoke($2, `\u{fff0}\u{fff1}\u{fff2}\u{fff3}\u{fff4}\u{fff5}\u{fff6}\u{fff7}`, []),
+  [value("i32", 27)],
+);
+
+// ./test/core/names.wast:643
+assert_return(
+  () => invoke($2, `\u{fff8}\u{fff9}\u{fffa}\u{fffb}\u{fffc}\u{fffd}\u{fffe}\u{ffff}`, []),
+  [value("i32", 28)],
+);
+
+// ./test/core/names.wast:644
+assert_return(
+  () => invoke($2, `\u{2400}\u{2401}\u{2402}\u{2403}\u{2404}\u{2405}\u{2406}\u{2407}\u{2408}\u{2409}\u{240a}\u{240b}\u{240c}\u{240d}\u{240e}\u{240f}`, []),
+  [value("i32", 29)],
+);
+
+// ./test/core/names.wast:645
+assert_return(
+  () => invoke($2, `\u{2410}\u{2411}\u{2412}\u{2413}\u{2414}\u{2415}\u{2416}\u{2417}\u{2418}\u{2419}\u{241a}\u{241b}\u{241c}\u{241d}\u{241e}\u{241f}`, []),
+  [value("i32", 30)],
+);
+
+// ./test/core/names.wast:646
+assert_return(() => invoke($2, `\u{2420}\u{2421}`, []), [value("i32", 31)]);
+
+// ./test/core/names.wast:647
+assert_return(
+  () => invoke($2, `\u{fff0}\u{fff1}\u{fff2}\u{fff3}\u{fff4}\u{fff5}\u{fff6}\u{fff7}\u{fff8}\u{fff9}\u{fffa}\u{fffb}\u{fffc}\u{fffd}`, []),
+  [value("i32", 32)],
+);
+
+// ./test/core/names.wast:648
+assert_return(() => invoke($2, `\u{200d}`, []), [value("i32", 33)]);
+
+// ./test/core/names.wast:649
+assert_return(() => invoke($2, `\u{200c}`, []), [value("i32", 34)]);
+
+// ./test/core/names.wast:650
+assert_return(() => invoke($2, `\u{34f}`, []), [value("i32", 35)]);
+
+// ./test/core/names.wast:651
+assert_return(() => invoke($2, `\u{2060}`, []), [value("i32", 36)]);
+
+// ./test/core/names.wast:652
+assert_return(() => invoke($2, `\u{2d7f}`, []), [value("i32", 37)]);
+
+// ./test/core/names.wast:653
+assert_return(() => invoke($2, `\u{1107f}`, []), [value("i32", 38)]);
+
+// ./test/core/names.wast:654
+assert_return(() => invoke($2, `\u{180e}`, []), [value("i32", 39)]);
+
+// ./test/core/names.wast:655
+assert_return(
+  () => invoke($2, `\u{ffef}\u{200b}\u{a0}\u{ad}\u{2060}\u{1680}\u{202e}\u{202d}`, []),
+  [value("i32", 40)],
+);
+
+// ./test/core/names.wast:656
+assert_return(
+  () => invoke($2, `\u{200e}\u{200f}\u{2011}\u{2028}\u{2029}\u{202a}\u{202b}\u{202c}\u{202f}\u{2066}\u{2067}\u{2068}\u{2069}`, []),
+  [value("i32", 41)],
+);
+
+// ./test/core/names.wast:657
+assert_return(
+  () => invoke($2, `\u{206a}\u{206b}\u{206c}\u{206d}\u{206e}\u{206f}`, []),
+  [value("i32", 42)],
+);
+
+// ./test/core/names.wast:658
+assert_return(() => invoke($2, `\u{2061}\u{2062}\u{2063}\u{2064}`, []), [value("i32", 43)]);
+
+// ./test/core/names.wast:659
+assert_return(() => invoke($2, `\u{10000}\u{dffff}\u{10ffff}`, []), [value("i32", 44)]);
+
+// ./test/core/names.wast:660
+assert_return(
+  () => invoke($2, `Z\u{30f}\u{346}\u{306}\u{35b}\u{34c}\u{334}\u{358}\u{35e}\u{347}\u{32b}\u{325}\u{32a}\u{353}\u{348}\u{354}\u{34e}\u{317}\u{31e}\u{33a}\u{32f}\u{331}\u{31e}\u{319}\u{331}\u{31c}\u{316}\u{320}a\u{357}\u{368}\u{30e}\u{304}\u{306}\u{357}\u{33f}\u{361}\u{35f}\u{340}\u{336}\u{341}\u{325}\u{330}\u{333}\u{32d}\u{359}\u{332}\u{331}\u{339}\u{31d}\u{34e}\u{33c}l\u{344}\u{34a}\u{31a}\u{357}\u{366}\u{344}\u{36b}\u{307}\u{341}\u{336}\u{337}\u{349}\u{329}\u{339}\u{32b}\u{31d}\u{356}\u{345}\u{319}\u{332}\u{33c}\u{347}\u{35a}\u{34d}\u{32e}\u{34e}\u{325}\u{345}\u{31e}g\u{343}\u{310}\u{305}\u{36e}\u{314}\u{310}\u{30e}\u{302}\u{30f}\u{33e}\u{34a}\u{30d}\u{34b}\u{34a}\u{367}\u{301}\u{306}\u{366}\u{35e}\u{336}\u{355}\u{354}\u{35a}\u{329}o\u{34b}\u{314}\u{350}\u{36a}\u{369}\u{321}\u{34f}\u{322}\u{327}\u{341}\u{32b}\u{319}\u{324}\u{32e}\u{356}\u{359}\u{353}\u{33a}\u{31c}\u{329}\u{33c}\u{318}\u{320}`, []),
+  [value("i32", 45)],
+);
+
+// ./test/core/names.wast:661
+assert_return(() => invoke($2, `\u{115f}\u{1160}\u{3164}\u{ffa0}`, []), [value("i32", 46)]);
+
+// ./test/core/names.wast:662
+assert_return(() => invoke($2, `\u{fe00}`, []), [value("i32", 47)]);
+
+// ./test/core/names.wast:663
+assert_return(() => invoke($2, `\u{fe04}`, []), [value("i32", 48)]);
+
+// ./test/core/names.wast:664
+assert_return(() => invoke($2, `\u{e0100}`, []), [value("i32", 49)]);
+
+// ./test/core/names.wast:665
+assert_return(() => invoke($2, `\u{e01ef}`, []), [value("i32", 50)]);
+
+// ./test/core/names.wast:666
+assert_return(() => invoke($2, `\u{308}`, []), [value("i32", 51)]);
+
+// ./test/core/names.wast:667
+assert_return(() => invoke($2, `
+`, []), [value("i32", 52)]);
+
+// ./test/core/names.wast:668
+assert_return(() => invoke($2, `\u{2424}`, []), [value("i32", 53)]);
+
+// ./test/core/names.wast:669
+assert_return(() => invoke($2, `\u{2028}`, []), [value("i32", 54)]);
+
+// ./test/core/names.wast:670
+assert_return(() => invoke($2, `\x0d`, []), [value("i32", 55)]);
+
+// ./test/core/names.wast:671
+assert_return(() => invoke($2, `\x0d
+`, []), [value("i32", 56)]);
+
+// ./test/core/names.wast:672
+assert_return(() => invoke($2, `
+\x0d`, []), [value("i32", 57)]);
+
+// ./test/core/names.wast:673
+assert_return(() => invoke($2, `\x1e`, []), [value("i32", 58)]);
+
+// ./test/core/names.wast:674
+assert_return(() => invoke($2, `\x0b`, []), [value("i32", 59)]);
+
+// ./test/core/names.wast:675
+assert_return(() => invoke($2, `\x0c`, []), [value("i32", 60)]);
+
+// ./test/core/names.wast:676
+assert_return(() => invoke($2, `\u{85}`, []), [value("i32", 61)]);
+
+// ./test/core/names.wast:677
+assert_return(() => invoke($2, `\u{2029}`, []), [value("i32", 62)]);
+
+// ./test/core/names.wast:678
+assert_return(() => invoke($2, `\u{2026}`, []), [value("i32", 63)]);
+
+// ./test/core/names.wast:679
+assert_return(() => invoke($2, `\u{23ce}`, []), [value("i32", 64)]);
+
+// ./test/core/names.wast:680
+assert_return(() => invoke($2, `\u{8b}`, []), [value("i32", 65)]);
+
+// ./test/core/names.wast:681
+assert_return(() => invoke($2, `\u{8c}`, []), [value("i32", 66)]);
+
+// ./test/core/names.wast:682
+assert_return(() => invoke($2, `\u{8d}`, []), [value("i32", 67)]);
+
+// ./test/core/names.wast:683
+assert_return(() => invoke($2, `\u{21b5}`, []), [value("i32", 68)]);
+
+// ./test/core/names.wast:684
+assert_return(() => invoke($2, `\u{21a9}`, []), [value("i32", 69)]);
+
+// ./test/core/names.wast:685
+assert_return(() => invoke($2, `\u{2324}`, []), [value("i32", 70)]);
+
+// ./test/core/names.wast:686
+assert_return(() => invoke($2, `\u{2936}`, []), [value("i32", 71)]);
+
+// ./test/core/names.wast:687
+assert_return(() => invoke($2, `\u{21b2}`, []), [value("i32", 72)]);
+
+// ./test/core/names.wast:688
+assert_return(() => invoke($2, `\u{2ba8}`, []), [value("i32", 73)]);
+
+// ./test/core/names.wast:689
+assert_return(() => invoke($2, `\u{2bb0}`, []), [value("i32", 74)]);
+
+// ./test/core/names.wast:690
+assert_return(() => invoke($2, `\u{fffd}`, []), [value("i32", 75)]);
+
+// ./test/core/names.wast:691
+assert_return(() => invoke($2, `\u{fdd0}`, []), [value("i32", 76)]);
+
+// ./test/core/names.wast:692
+assert_return(() => invoke($2, `\u{fdd1}`, []), [value("i32", 77)]);
+
+// ./test/core/names.wast:693
+assert_return(() => invoke($2, `\u{fdd2}`, []), [value("i32", 78)]);
+
+// ./test/core/names.wast:694
+assert_return(() => invoke($2, `\u{fdd3}`, []), [value("i32", 79)]);
+
+// ./test/core/names.wast:695
+assert_return(() => invoke($2, `\u{fdd4}`, []), [value("i32", 80)]);
+
+// ./test/core/names.wast:696
+assert_return(() => invoke($2, `\u{fdd5}`, []), [value("i32", 81)]);
+
+// ./test/core/names.wast:697
+assert_return(() => invoke($2, `\u{fdd6}`, []), [value("i32", 82)]);
+
+// ./test/core/names.wast:698
+assert_return(() => invoke($2, `\u{fdd7}`, []), [value("i32", 83)]);
+
+// ./test/core/names.wast:699
+assert_return(() => invoke($2, `\u{fdd8}`, []), [value("i32", 84)]);
+
+// ./test/core/names.wast:700
+assert_return(() => invoke($2, `\u{fdd9}`, []), [value("i32", 85)]);
+
+// ./test/core/names.wast:701
+assert_return(() => invoke($2, `\u{fdda}`, []), [value("i32", 86)]);
+
+// ./test/core/names.wast:702
+assert_return(() => invoke($2, `\u{fddb}`, []), [value("i32", 87)]);
+
+// ./test/core/names.wast:703
+assert_return(() => invoke($2, `\u{fddc}`, []), [value("i32", 88)]);
+
+// ./test/core/names.wast:704
+assert_return(() => invoke($2, `\u{fddd}`, []), [value("i32", 89)]);
+
+// ./test/core/names.wast:705
+assert_return(() => invoke($2, `\u{fdde}`, []), [value("i32", 90)]);
+
+// ./test/core/names.wast:706
+assert_return(() => invoke($2, `\u{fddf}`, []), [value("i32", 91)]);
+
+// ./test/core/names.wast:707
+assert_return(() => invoke($2, `\u{fde0}`, []), [value("i32", 92)]);
+
+// ./test/core/names.wast:708
+assert_return(() => invoke($2, `\u{fde1}`, []), [value("i32", 93)]);
+
+// ./test/core/names.wast:709
+assert_return(() => invoke($2, `\u{fde2}`, []), [value("i32", 94)]);
+
+// ./test/core/names.wast:710
+assert_return(() => invoke($2, `\u{fde3}`, []), [value("i32", 95)]);
+
+// ./test/core/names.wast:711
+assert_return(() => invoke($2, `\u{fde4}`, []), [value("i32", 96)]);
+
+// ./test/core/names.wast:712
+assert_return(() => invoke($2, `\u{fde5}`, []), [value("i32", 97)]);
+
+// ./test/core/names.wast:713
+assert_return(() => invoke($2, `\u{fde6}`, []), [value("i32", 98)]);
+
+// ./test/core/names.wast:714
+assert_return(() => invoke($2, `\u{fde7}`, []), [value("i32", 99)]);
+
+// ./test/core/names.wast:715
+assert_return(() => invoke($2, `\u{fde8}`, []), [value("i32", 100)]);
+
+// ./test/core/names.wast:716
+assert_return(() => invoke($2, `\u{fde9}`, []), [value("i32", 101)]);
+
+// ./test/core/names.wast:717
+assert_return(() => invoke($2, `\u{fdea}`, []), [value("i32", 102)]);
+
+// ./test/core/names.wast:718
+assert_return(() => invoke($2, `\u{fdeb}`, []), [value("i32", 103)]);
+
+// ./test/core/names.wast:719
+assert_return(() => invoke($2, `\u{fdec}`, []), [value("i32", 104)]);
+
+// ./test/core/names.wast:720
+assert_return(() => invoke($2, `\u{fded}`, []), [value("i32", 105)]);
+
+// ./test/core/names.wast:721
+assert_return(() => invoke($2, `\u{fdee}`, []), [value("i32", 106)]);
+
+// ./test/core/names.wast:722
+assert_return(() => invoke($2, `\u{fdef}`, []), [value("i32", 107)]);
+
+// ./test/core/names.wast:723
+assert_return(() => invoke($2, `\u{fffe}`, []), [value("i32", 108)]);
+
+// ./test/core/names.wast:724
+assert_return(() => invoke($2, `\u{ffff}`, []), [value("i32", 109)]);
+
+// ./test/core/names.wast:725
+assert_return(() => invoke($2, `\u{1fffe}`, []), [value("i32", 110)]);
+
+// ./test/core/names.wast:726
+assert_return(() => invoke($2, `\u{1ffff}`, []), [value("i32", 111)]);
+
+// ./test/core/names.wast:727
+assert_return(() => invoke($2, `\u{2fffe}`, []), [value("i32", 112)]);
+
+// ./test/core/names.wast:728
+assert_return(() => invoke($2, `\u{2ffff}`, []), [value("i32", 113)]);
+
+// ./test/core/names.wast:729
+assert_return(() => invoke($2, `\u{3fffe}`, []), [value("i32", 114)]);
+
+// ./test/core/names.wast:730
+assert_return(() => invoke($2, `\u{3ffff}`, []), [value("i32", 115)]);
+
+// ./test/core/names.wast:731
+assert_return(() => invoke($2, `\u{4fffe}`, []), [value("i32", 116)]);
+
+// ./test/core/names.wast:732
+assert_return(() => invoke($2, `\u{4ffff}`, []), [value("i32", 117)]);
+
+// ./test/core/names.wast:733
+assert_return(() => invoke($2, `\u{5fffe}`, []), [value("i32", 118)]);
+
+// ./test/core/names.wast:734
+assert_return(() => invoke($2, `\u{5ffff}`, []), [value("i32", 119)]);
+
+// ./test/core/names.wast:735
+assert_return(() => invoke($2, `\u{6fffe}`, []), [value("i32", 120)]);
+
+// ./test/core/names.wast:736
+assert_return(() => invoke($2, `\u{6ffff}`, []), [value("i32", 121)]);
+
+// ./test/core/names.wast:737
+assert_return(() => invoke($2, `\u{7fffe}`, []), [value("i32", 122)]);
+
+// ./test/core/names.wast:738
+assert_return(() => invoke($2, `\u{7ffff}`, []), [value("i32", 123)]);
+
+// ./test/core/names.wast:739
+assert_return(() => invoke($2, `\u{8fffe}`, []), [value("i32", 124)]);
+
+// ./test/core/names.wast:740
+assert_return(() => invoke($2, `\u{8ffff}`, []), [value("i32", 125)]);
+
+// ./test/core/names.wast:741
+assert_return(() => invoke($2, `\u{9fffe}`, []), [value("i32", 126)]);
+
+// ./test/core/names.wast:742
+assert_return(() => invoke($2, `\u{9ffff}`, []), [value("i32", 127)]);
+
+// ./test/core/names.wast:743
+assert_return(() => invoke($2, `\u{afffe}`, []), [value("i32", 128)]);
+
+// ./test/core/names.wast:744
+assert_return(() => invoke($2, `\u{affff}`, []), [value("i32", 129)]);
+
+// ./test/core/names.wast:745
+assert_return(() => invoke($2, `\u{bfffe}`, []), [value("i32", 130)]);
+
+// ./test/core/names.wast:746
+assert_return(() => invoke($2, `\u{bffff}`, []), [value("i32", 131)]);
+
+// ./test/core/names.wast:747
+assert_return(() => invoke($2, `\u{cfffe}`, []), [value("i32", 132)]);
+
+// ./test/core/names.wast:748
+assert_return(() => invoke($2, `\u{cffff}`, []), [value("i32", 133)]);
+
+// ./test/core/names.wast:749
+assert_return(() => invoke($2, `\u{dfffe}`, []), [value("i32", 134)]);
+
+// ./test/core/names.wast:750
+assert_return(() => invoke($2, `\u{dffff}`, []), [value("i32", 135)]);
+
+// ./test/core/names.wast:751
+assert_return(() => invoke($2, `\u{efffe}`, []), [value("i32", 136)]);
+
+// ./test/core/names.wast:752
+assert_return(() => invoke($2, `\u{effff}`, []), [value("i32", 137)]);
+
+// ./test/core/names.wast:753
+assert_return(() => invoke($2, `\u{ffffe}`, []), [value("i32", 138)]);
+
+// ./test/core/names.wast:754
+assert_return(() => invoke($2, `\u{fffff}`, []), [value("i32", 139)]);
+
+// ./test/core/names.wast:755
+assert_return(() => invoke($2, `\u{10fffe}`, []), [value("i32", 140)]);
+
+// ./test/core/names.wast:756
+assert_return(() => invoke($2, `\u{10ffff}`, []), [value("i32", 141)]);
+
+// ./test/core/names.wast:757
+assert_return(() => invoke($2, `\u{308}\u{203d}\u{308}\u{309}`, []), [value("i32", 142)]);
+
+// ./test/core/names.wast:758
+assert_return(() => invoke($2, `abc`, []), [value("i32", 143)]);
+
+// ./test/core/names.wast:759
+assert_return(() => invoke($2, `\u{202d}abc`, []), [value("i32", 144)]);
+
+// ./test/core/names.wast:760
+assert_return(() => invoke($2, `\u{202e}cba`, []), [value("i32", 145)]);
+
+// ./test/core/names.wast:761
+assert_return(() => invoke($2, `\u{202d}abc\u{202e}`, []), [value("i32", 146)]);
+
+// ./test/core/names.wast:762
+assert_return(() => invoke($2, `\u{202e}cba\u{202d}`, []), [value("i32", 147)]);
+
+// ./test/core/names.wast:763
+assert_return(() => invoke($2, `\u{1d468}`, []), [value("i32", 148)]);
+
+// ./test/core/names.wast:764
+assert_return(() => invoke($2, `\u{1d434}`, []), [value("i32", 149)]);
+
+// ./test/core/names.wast:765
+assert_return(() => invoke($2, `\u{1d608}`, []), [value("i32", 150)]);
+
+// ./test/core/names.wast:766
+assert_return(() => invoke($2, `\u{1d63c}`, []), [value("i32", 151)]);
+
+// ./test/core/names.wast:767
+assert_return(() => invoke($2, `\u{1d400}`, []), [value("i32", 152)]);
+
+// ./test/core/names.wast:768
+assert_return(() => invoke($2, `\u{1d4d0}`, []), [value("i32", 153)]);
+
+// ./test/core/names.wast:769
+assert_return(() => invoke($2, `\u{1d56c}`, []), [value("i32", 154)]);
+
+// ./test/core/names.wast:770
+assert_return(() => invoke($2, `\u{1d5d4}`, []), [value("i32", 155)]);
+
+// ./test/core/names.wast:771
+assert_return(() => invoke($2, `\u{1d49c}`, []), [value("i32", 156)]);
+
+// ./test/core/names.wast:772
+assert_return(() => invoke($2, `\u{1d504}`, []), [value("i32", 157)]);
+
+// ./test/core/names.wast:773
+assert_return(() => invoke($2, `\u{1d538}`, []), [value("i32", 158)]);
+
+// ./test/core/names.wast:774
+assert_return(() => invoke($2, `\u{1d5a0}`, []), [value("i32", 159)]);
+
+// ./test/core/names.wast:775
+assert_return(() => invoke($2, `\u{1d670}`, []), [value("i32", 160)]);
+
+// ./test/core/names.wast:776
+assert_return(() => invoke($2, `\u{1d00}`, []), [value("i32", 161)]);
+
+// ./test/core/names.wast:777
+assert_return(() => invoke($2, `\u{1d2c}`, []), [value("i32", 162)]);
+
+// ./test/core/names.wast:778
+assert_return(() => invoke($2, `\u{24b6}`, []), [value("i32", 163)]);
+
+// ./test/core/names.wast:779
+assert_return(() => invoke($2, `\u{ff21}`, []), [value("i32", 164)]);
+
+// ./test/core/names.wast:780
+assert_return(() => invoke($2, `\u{1f110}`, []), [value("i32", 165)]);
+
+// ./test/core/names.wast:781
+assert_return(() => invoke($2, `\u{1f130}`, []), [value("i32", 166)]);
+
+// ./test/core/names.wast:782
+assert_return(() => invoke($2, `\u{e0041}`, []), [value("i32", 167)]);
+
+// ./test/core/names.wast:783
+assert_return(() => invoke($2, `U+0041`, []), [value("i32", 168)]);
+
+// ./test/core/names.wast:784
+assert_return(() => invoke($2, `A\u{200b}`, []), [value("i32", 169)]);
+
+// ./test/core/names.wast:785
+assert_return(() => invoke($2, `\u{410}`, []), [value("i32", 170)]);
+
+// ./test/core/names.wast:786
+assert_return(() => invoke($2, `\u{a656}`, []), [value("i32", 171)]);
+
+// ./test/core/names.wast:787
+assert_return(() => invoke($2, `\u{2dfc}`, []), [value("i32", 172)]);
+
+// ./test/core/names.wast:788
+assert_return(() => invoke($2, `\u{2df6}`, []), [value("i32", 173)]);
+
+// ./test/core/names.wast:789
+assert_return(() => invoke($2, `\u{2c6f}`, []), [value("i32", 174)]);
+
+// ./test/core/names.wast:790
+assert_return(() => invoke($2, `\u{1f150}`, []), [value("i32", 175)]);
+
+// ./test/core/names.wast:791
+assert_return(() => invoke($2, `\u{1f170}`, []), [value("i32", 176)]);
+
+// ./test/core/names.wast:792
+assert_return(() => invoke($2, `\u{2c2d}`, []), [value("i32", 177)]);
+
+// ./test/core/names.wast:793
+assert_return(() => invoke($2, `\u{10402}`, []), [value("i32", 178)]);
+
+// ./test/core/names.wast:794
+assert_return(() => invoke($2, `\u{10408}`, []), [value("i32", 179)]);
+
+// ./test/core/names.wast:795
+assert_return(() => invoke($2, `\u{104b0}`, []), [value("i32", 180)]);
+
+// ./test/core/names.wast:796
+assert_return(() => invoke($2, `\u{c0}`, []), [value("i32", 181)]);
+
+// ./test/core/names.wast:797
+assert_return(() => invoke($2, `\u{c1}`, []), [value("i32", 182)]);
+
+// ./test/core/names.wast:798
+assert_return(() => invoke($2, `\u{c2}`, []), [value("i32", 183)]);
+
+// ./test/core/names.wast:799
+assert_return(() => invoke($2, `\u{c3}`, []), [value("i32", 184)]);
+
+// ./test/core/names.wast:800
+assert_return(() => invoke($2, `\u{c4}`, []), [value("i32", 185)]);
+
+// ./test/core/names.wast:801
+assert_return(() => invoke($2, `\u{100}`, []), [value("i32", 186)]);
+
+// ./test/core/names.wast:802
+assert_return(() => invoke($2, `\u{102}`, []), [value("i32", 187)]);
+
+// ./test/core/names.wast:803
+assert_return(() => invoke($2, `\u{104}`, []), [value("i32", 188)]);
+
+// ./test/core/names.wast:804
+assert_return(() => invoke($2, `\u{1cd}`, []), [value("i32", 189)]);
+
+// ./test/core/names.wast:805
+assert_return(() => invoke($2, `\u{1de}`, []), [value("i32", 190)]);
+
+// ./test/core/names.wast:806
+assert_return(() => invoke($2, `\u{1e0}`, []), [value("i32", 191)]);
+
+// ./test/core/names.wast:807
+assert_return(() => invoke($2, `\u{1fa}`, []), [value("i32", 192)]);
+
+// ./test/core/names.wast:808
+assert_return(() => invoke($2, `\u{200}`, []), [value("i32", 193)]);
+
+// ./test/core/names.wast:809
+assert_return(() => invoke($2, `\u{202}`, []), [value("i32", 194)]);
+
+// ./test/core/names.wast:810
+assert_return(() => invoke($2, `\u{226}`, []), [value("i32", 195)]);
+
+// ./test/core/names.wast:811
+assert_return(() => invoke($2, `\u{23a}`, []), [value("i32", 196)]);
+
+// ./test/core/names.wast:812
+assert_return(() => invoke($2, `\u{4d0}`, []), [value("i32", 197)]);
+
+// ./test/core/names.wast:813
+assert_return(() => invoke($2, `\u{4d2}`, []), [value("i32", 198)]);
+
+// ./test/core/names.wast:814
+assert_return(() => invoke($2, `\u{7ca}`, []), [value("i32", 199)]);
+
+// ./test/core/names.wast:815
+assert_return(() => invoke($2, `\u{821}`, []), [value("i32", 200)]);
+
+// ./test/core/names.wast:816
+assert_return(() => invoke($2, `\u{822}`, []), [value("i32", 201)]);
+
+// ./test/core/names.wast:817
+assert_return(() => invoke($2, `\u{823}`, []), [value("i32", 202)]);
+
+// ./test/core/names.wast:818
+assert_return(() => invoke($2, `\u{824}`, []), [value("i32", 203)]);
+
+// ./test/core/names.wast:819
+assert_return(() => invoke($2, `\u{825}`, []), [value("i32", 204)]);
+
+// ./test/core/names.wast:820
+assert_return(() => invoke($2, `\u{904}`, []), [value("i32", 205)]);
+
+// ./test/core/names.wast:821
+assert_return(() => invoke($2, `\u{905}`, []), [value("i32", 206)]);
+
+// ./test/core/names.wast:822
+assert_return(() => invoke($2, `\u{972}`, []), [value("i32", 207)]);
+
+// ./test/core/names.wast:823
+assert_return(() => invoke($2, `\u{985}`, []), [value("i32", 208)]);
+
+// ./test/core/names.wast:824
+assert_return(() => invoke($2, `\u{a05}`, []), [value("i32", 209)]);
+
+// ./test/core/names.wast:825
+assert_return(() => invoke($2, `\u{a85}`, []), [value("i32", 210)]);
+
+// ./test/core/names.wast:826
+assert_return(() => invoke($2, `\u{b05}`, []), [value("i32", 211)]);
+
+// ./test/core/names.wast:827
+assert_return(() => invoke($2, `\u{b85}`, []), [value("i32", 212)]);
+
+// ./test/core/names.wast:828
+assert_return(() => invoke($2, `\u{c05}`, []), [value("i32", 213)]);
+
+// ./test/core/names.wast:829
+assert_return(() => invoke($2, `\u{c85}`, []), [value("i32", 214)]);
+
+// ./test/core/names.wast:830
+assert_return(() => invoke($2, `\u{d05}`, []), [value("i32", 215)]);
+
+// ./test/core/names.wast:831
+assert_return(() => invoke($2, `\u{e30}`, []), [value("i32", 216)]);
+
+// ./test/core/names.wast:832
+assert_return(() => invoke($2, `\u{eb0}`, []), [value("i32", 217)]);
+
+// ./test/core/names.wast:833
+assert_return(() => invoke($2, `\u{f01}`, []), [value("i32", 218)]);
+
+// ./test/core/names.wast:834
+assert_return(() => invoke($2, `\u{f68}`, []), [value("i32", 219)]);
+
+// ./test/core/names.wast:835
+assert_return(() => invoke($2, `\u{fb8}`, []), [value("i32", 220)]);
+
+// ./test/core/names.wast:836
+assert_return(() => invoke($2, `\u{1021}`, []), [value("i32", 221)]);
+
+// ./test/core/names.wast:837
+assert_return(() => invoke($2, `\u{1022}`, []), [value("i32", 222)]);
+
+// ./test/core/names.wast:838
+assert_return(() => invoke($2, `\u{109c}`, []), [value("i32", 223)]);
+
+// ./test/core/names.wast:839
+assert_return(() => invoke($2, `\u{1161}`, []), [value("i32", 224)]);
+
+// ./test/core/names.wast:840
+assert_return(() => invoke($2, `\u{12a0}`, []), [value("i32", 225)]);
+
+// ./test/core/names.wast:841
+assert_return(() => invoke($2, `\u{12d0}`, []), [value("i32", 226)]);
+
+// ./test/core/names.wast:842
+assert_return(() => invoke($2, `\u{13a0}`, []), [value("i32", 227)]);
+
+// ./test/core/names.wast:843
+assert_return(() => invoke($2, `\u{140a}`, []), [value("i32", 228)]);
+
+// ./test/core/names.wast:844
+assert_return(() => invoke($2, `\u{15b3}`, []), [value("i32", 229)]);
+
+// ./test/core/names.wast:845
+assert_return(() => invoke($2, `\u{16a8}`, []), [value("i32", 230)]);
+
+// ./test/core/names.wast:846
+assert_return(() => invoke($2, `\u{16aa}`, []), [value("i32", 231)]);
+
+// ./test/core/names.wast:847
+assert_return(() => invoke($2, `\u{16c6}`, []), [value("i32", 232)]);
+
+// ./test/core/names.wast:848
+assert_return(() => invoke($2, `\u{1700}`, []), [value("i32", 233)]);
+
+// ./test/core/names.wast:849
+assert_return(() => invoke($2, `\u{1720}`, []), [value("i32", 234)]);
+
+// ./test/core/names.wast:850
+assert_return(() => invoke($2, `\u{1740}`, []), [value("i32", 235)]);
+
+// ./test/core/names.wast:851
+assert_return(() => invoke($2, `\u{1760}`, []), [value("i32", 236)]);
+
+// ./test/core/names.wast:852
+assert_return(() => invoke($2, `\u{1820}`, []), [value("i32", 237)]);
+
+// ./test/core/names.wast:853
+assert_return(() => invoke($2, `\u{1887}`, []), [value("i32", 238)]);
+
+// ./test/core/names.wast:854
+assert_return(() => invoke($2, `\u{1920}`, []), [value("i32", 239)]);
+
+// ./test/core/names.wast:855
+assert_return(() => invoke($2, `\u{1963}`, []), [value("i32", 240)]);
+
+// ./test/core/names.wast:856
+assert_return(() => invoke($2, `\u{1a15}`, []), [value("i32", 241)]);
+
+// ./test/core/names.wast:857
+assert_return(() => invoke($2, `\u{1a4b}`, []), [value("i32", 242)]);
+
+// ./test/core/names.wast:858
+assert_return(() => invoke($2, `\u{1a61}`, []), [value("i32", 243)]);
+
+// ./test/core/names.wast:859
+assert_return(() => invoke($2, `\u{1b83}`, []), [value("i32", 244)]);
+
+// ./test/core/names.wast:860
+assert_return(() => invoke($2, `\u{1bc0}`, []), [value("i32", 245)]);
+
+// ./test/core/names.wast:861
+assert_return(() => invoke($2, `\u{1bc1}`, []), [value("i32", 246)]);
+
+// ./test/core/names.wast:862
+assert_return(() => invoke($2, `\u{1c23}`, []), [value("i32", 247)]);
+
+// ./test/core/names.wast:863
+assert_return(() => invoke($2, `\u{1e00}`, []), [value("i32", 248)]);
+
+// ./test/core/names.wast:864
+assert_return(() => invoke($2, `\u{1ea0}`, []), [value("i32", 249)]);
+
+// ./test/core/names.wast:865
+assert_return(() => invoke($2, `\u{1ea2}`, []), [value("i32", 250)]);
+
+// ./test/core/names.wast:866
+assert_return(() => invoke($2, `\u{1ea4}`, []), [value("i32", 251)]);
+
+// ./test/core/names.wast:867
+assert_return(() => invoke($2, `\u{1ea6}`, []), [value("i32", 252)]);
+
+// ./test/core/names.wast:868
+assert_return(() => invoke($2, `\u{1ea8}`, []), [value("i32", 253)]);
+
+// ./test/core/names.wast:869
+assert_return(() => invoke($2, `\u{1eaa}`, []), [value("i32", 254)]);
+
+// ./test/core/names.wast:870
+assert_return(() => invoke($2, `\u{1eac}`, []), [value("i32", 255)]);
+
+// ./test/core/names.wast:871
+assert_return(() => invoke($2, `\u{1eae}`, []), [value("i32", 256)]);
+
+// ./test/core/names.wast:872
+assert_return(() => invoke($2, `\u{1eb0}`, []), [value("i32", 257)]);
+
+// ./test/core/names.wast:873
+assert_return(() => invoke($2, `\u{1eb2}`, []), [value("i32", 258)]);
+
+// ./test/core/names.wast:874
+assert_return(() => invoke($2, `\u{1eb4}`, []), [value("i32", 259)]);
+
+// ./test/core/names.wast:875
+assert_return(() => invoke($2, `\u{1eb6}`, []), [value("i32", 260)]);
+
+// ./test/core/names.wast:876
+assert_return(() => invoke($2, `\u{3042}`, []), [value("i32", 261)]);
+
+// ./test/core/names.wast:877
+assert_return(() => invoke($2, `\u{30a2}`, []), [value("i32", 262)]);
+
+// ./test/core/names.wast:878
+assert_return(() => invoke($2, `\u{311a}`, []), [value("i32", 263)]);
+
+// ./test/core/names.wast:879
+assert_return(() => invoke($2, `\u{314f}`, []), [value("i32", 264)]);
+
+// ./test/core/names.wast:880
+assert_return(() => invoke($2, `\u{320e}`, []), [value("i32", 265)]);
+
+// ./test/core/names.wast:881
+assert_return(() => invoke($2, `\u{320f}`, []), [value("i32", 266)]);
+
+// ./test/core/names.wast:882
+assert_return(() => invoke($2, `\u{3210}`, []), [value("i32", 267)]);
+
+// ./test/core/names.wast:883
+assert_return(() => invoke($2, `\u{3211}`, []), [value("i32", 268)]);
+
+// ./test/core/names.wast:884
+assert_return(() => invoke($2, `\u{3212}`, []), [value("i32", 269)]);
+
+// ./test/core/names.wast:885
+assert_return(() => invoke($2, `\u{3213}`, []), [value("i32", 270)]);
+
+// ./test/core/names.wast:886
+assert_return(() => invoke($2, `\u{3214}`, []), [value("i32", 271)]);
+
+// ./test/core/names.wast:887
+assert_return(() => invoke($2, `\u{3215}`, []), [value("i32", 272)]);
+
+// ./test/core/names.wast:888
+assert_return(() => invoke($2, `\u{3216}`, []), [value("i32", 273)]);
+
+// ./test/core/names.wast:889
+assert_return(() => invoke($2, `\u{3217}`, []), [value("i32", 274)]);
+
+// ./test/core/names.wast:890
+assert_return(() => invoke($2, `\u{3218}`, []), [value("i32", 275)]);
+
+// ./test/core/names.wast:891
+assert_return(() => invoke($2, `\u{3219}`, []), [value("i32", 276)]);
+
+// ./test/core/names.wast:892
+assert_return(() => invoke($2, `\u{321a}`, []), [value("i32", 277)]);
+
+// ./test/core/names.wast:893
+assert_return(() => invoke($2, `\u{321b}`, []), [value("i32", 278)]);
+
+// ./test/core/names.wast:894
+assert_return(() => invoke($2, `\u{326e}`, []), [value("i32", 279)]);
+
+// ./test/core/names.wast:895
+assert_return(() => invoke($2, `\u{326f}`, []), [value("i32", 280)]);
+
+// ./test/core/names.wast:896
+assert_return(() => invoke($2, `\u{3270}`, []), [value("i32", 281)]);
+
+// ./test/core/names.wast:897
+assert_return(() => invoke($2, `\u{3271}`, []), [value("i32", 282)]);
+
+// ./test/core/names.wast:898
+assert_return(() => invoke($2, `\u{3272}`, []), [value("i32", 283)]);
+
+// ./test/core/names.wast:899
+assert_return(() => invoke($2, `\u{3273}`, []), [value("i32", 284)]);
+
+// ./test/core/names.wast:900
+assert_return(() => invoke($2, `\u{3274}`, []), [value("i32", 285)]);
+
+// ./test/core/names.wast:901
+assert_return(() => invoke($2, `\u{3275}`, []), [value("i32", 286)]);
+
+// ./test/core/names.wast:902
+assert_return(() => invoke($2, `\u{3276}`, []), [value("i32", 287)]);
+
+// ./test/core/names.wast:903
+assert_return(() => invoke($2, `\u{3277}`, []), [value("i32", 288)]);
+
+// ./test/core/names.wast:904
+assert_return(() => invoke($2, `\u{3278}`, []), [value("i32", 289)]);
+
+// ./test/core/names.wast:905
+assert_return(() => invoke($2, `\u{3279}`, []), [value("i32", 290)]);
+
+// ./test/core/names.wast:906
+assert_return(() => invoke($2, `\u{327a}`, []), [value("i32", 291)]);
+
+// ./test/core/names.wast:907
+assert_return(() => invoke($2, `\u{327b}`, []), [value("i32", 292)]);
+
+// ./test/core/names.wast:908
+assert_return(() => invoke($2, `\u{32d0}`, []), [value("i32", 293)]);
+
+// ./test/core/names.wast:909
+assert_return(() => invoke($2, `\u{a00a}`, []), [value("i32", 294)]);
+
+// ./test/core/names.wast:910
+assert_return(() => invoke($2, `\u{a4ee}`, []), [value("i32", 295)]);
+
+// ./test/core/names.wast:911
+assert_return(() => invoke($2, `\u{a549}`, []), [value("i32", 296)]);
+
+// ./test/core/names.wast:912
+assert_return(() => invoke($2, `\u{a6a0}`, []), [value("i32", 297)]);
+
+// ./test/core/names.wast:913
+assert_return(() => invoke($2, `\u{a800}`, []), [value("i32", 298)]);
+
+// ./test/core/names.wast:914
+assert_return(() => invoke($2, `\u{a823}`, []), [value("i32", 299)]);
+
+// ./test/core/names.wast:915
+assert_return(() => invoke($2, `\u{a85d}`, []), [value("i32", 300)]);
+
+// ./test/core/names.wast:916
+assert_return(() => invoke($2, `\u{a882}`, []), [value("i32", 301)]);
+
+// ./test/core/names.wast:917
+assert_return(() => invoke($2, `\u{a8ea}`, []), [value("i32", 302)]);
+
+// ./test/core/names.wast:918
+assert_return(() => invoke($2, `\u{a922}`, []), [value("i32", 303)]);
+
+// ./test/core/names.wast:919
+assert_return(() => invoke($2, `\u{a946}`, []), [value("i32", 304)]);
+
+// ./test/core/names.wast:920
+assert_return(() => invoke($2, `\u{a984}`, []), [value("i32", 305)]);
+
+// ./test/core/names.wast:921
+assert_return(() => invoke($2, `\u{aa00}`, []), [value("i32", 306)]);
+
+// ./test/core/names.wast:922
+assert_return(() => invoke($2, `\u{ff71}`, []), [value("i32", 307)]);
+
+// ./test/core/names.wast:923
+assert_return(() => invoke($2, `\u{ffc2}`, []), [value("i32", 308)]);
+
+// ./test/core/names.wast:924
+assert_return(() => invoke($2, `\u{10000}`, []), [value("i32", 309)]);
+
+// ./test/core/names.wast:925
+assert_return(() => invoke($2, `\u{10280}`, []), [value("i32", 310)]);
+
+// ./test/core/names.wast:926
+assert_return(() => invoke($2, `\u{102a0}`, []), [value("i32", 311)]);
+
+// ./test/core/names.wast:927
+assert_return(() => invoke($2, `\u{10300}`, []), [value("i32", 312)]);
+
+// ./test/core/names.wast:928
+assert_return(() => invoke($2, `\u{103a0}`, []), [value("i32", 313)]);
+
+// ./test/core/names.wast:929
+assert_return(() => invoke($2, `\u{10496}`, []), [value("i32", 314)]);
+
+// ./test/core/names.wast:930
+assert_return(() => invoke($2, `\u{10500}`, []), [value("i32", 315)]);
+
+// ./test/core/names.wast:931
+assert_return(() => invoke($2, `\u{10740}`, []), [value("i32", 316)]);
+
+// ./test/core/names.wast:932
+assert_return(() => invoke($2, `\u{10800}`, []), [value("i32", 317)]);
+
+// ./test/core/names.wast:933
+assert_return(() => invoke($2, `\u{10920}`, []), [value("i32", 318)]);
+
+// ./test/core/names.wast:934
+assert_return(() => invoke($2, `\u{10980}`, []), [value("i32", 319)]);
+
+// ./test/core/names.wast:935
+assert_return(() => invoke($2, `\u{109a0}`, []), [value("i32", 320)]);
+
+// ./test/core/names.wast:936
+assert_return(() => invoke($2, `\u{10a00}`, []), [value("i32", 321)]);
+
+// ./test/core/names.wast:937
+assert_return(() => invoke($2, `\u{10b00}`, []), [value("i32", 322)]);
+
+// ./test/core/names.wast:938
+assert_return(() => invoke($2, `\u{10c00}`, []), [value("i32", 323)]);
+
+// ./test/core/names.wast:939
+assert_return(() => invoke($2, `\u{10c01}`, []), [value("i32", 324)]);
+
+// ./test/core/names.wast:940
+assert_return(() => invoke($2, `\u{10c80}`, []), [value("i32", 325)]);
+
+// ./test/core/names.wast:941
+assert_return(() => invoke($2, `\u{11005}`, []), [value("i32", 326)]);
+
+// ./test/core/names.wast:942
+assert_return(() => invoke($2, `\u{11083}`, []), [value("i32", 327)]);
+
+// ./test/core/names.wast:943
+assert_return(() => invoke($2, `\u{11127}`, []), [value("i32", 328)]);
+
+// ./test/core/names.wast:944
+assert_return(() => invoke($2, `\u{11150}`, []), [value("i32", 329)]);
+
+// ./test/core/names.wast:945
+assert_return(() => invoke($2, `\u{11183}`, []), [value("i32", 330)]);
+
+// ./test/core/names.wast:946
+assert_return(() => invoke($2, `\u{11200}`, []), [value("i32", 331)]);
+
+// ./test/core/names.wast:947
+assert_return(() => invoke($2, `\u{11280}`, []), [value("i32", 332)]);
+
+// ./test/core/names.wast:948
+assert_return(() => invoke($2, `\u{112b0}`, []), [value("i32", 333)]);
+
+// ./test/core/names.wast:949
+assert_return(() => invoke($2, `\u{11305}`, []), [value("i32", 334)]);
+
+// ./test/core/names.wast:950
+assert_return(() => invoke($2, `\u{11370}`, []), [value("i32", 335)]);
+
+// ./test/core/names.wast:951
+assert_return(() => invoke($2, `\u{11400}`, []), [value("i32", 336)]);
+
+// ./test/core/names.wast:952
+assert_return(() => invoke($2, `\u{11481}`, []), [value("i32", 337)]);
+
+// ./test/core/names.wast:953
+assert_return(() => invoke($2, `\u{11580}`, []), [value("i32", 338)]);
+
+// ./test/core/names.wast:954
+assert_return(() => invoke($2, `\u{11600}`, []), [value("i32", 339)]);
+
+// ./test/core/names.wast:955
+assert_return(() => invoke($2, `\u{11680}`, []), [value("i32", 340)]);
+
+// ./test/core/names.wast:956
+assert_return(() => invoke($2, `\u{11712}`, []), [value("i32", 341)]);
+
+// ./test/core/names.wast:957
+assert_return(() => invoke($2, `\u{11720}`, []), [value("i32", 342)]);
+
+// ./test/core/names.wast:958
+assert_return(() => invoke($2, `\u{118a1}`, []), [value("i32", 343)]);
+
+// ./test/core/names.wast:959
+assert_return(() => invoke($2, `\u{11ad5}`, []), [value("i32", 344)]);
+
+// ./test/core/names.wast:960
+assert_return(() => invoke($2, `\u{11c00}`, []), [value("i32", 345)]);
+
+// ./test/core/names.wast:961
+assert_return(() => invoke($2, `\u{11c8f}`, []), [value("i32", 346)]);
+
+// ./test/core/names.wast:962
+assert_return(() => invoke($2, `\u{11caf}`, []), [value("i32", 347)]);
+
+// ./test/core/names.wast:963
+assert_return(() => invoke($2, `\u{12000}`, []), [value("i32", 348)]);
+
+// ./test/core/names.wast:964
+assert_return(() => invoke($2, `\u{169d5}`, []), [value("i32", 349)]);
+
+// ./test/core/names.wast:965
+assert_return(() => invoke($2, `\u{16a46}`, []), [value("i32", 350)]);
+
+// ./test/core/names.wast:966
+assert_return(() => invoke($2, `\u{16ae7}`, []), [value("i32", 351)]);
+
+// ./test/core/names.wast:967
+assert_return(() => invoke($2, `\u{16f54}`, []), [value("i32", 352)]);
+
+// ./test/core/names.wast:968
+assert_return(() => invoke($2, `\u{1bc41}`, []), [value("i32", 353)]);
+
+// ./test/core/names.wast:969
+assert_return(() => invoke($2, `\u{1bc64}`, []), [value("i32", 354)]);
+
+// ./test/core/names.wast:970
+assert_return(() => invoke($2, `\u{1e823}`, []), [value("i32", 355)]);
+
+// ./test/core/names.wast:971
+assert_return(() => invoke($2, `\u{1f1e6}`, []), [value("i32", 356)]);
+
+// ./test/core/names.wast:972
+assert_return(() => invoke($2, `\u{2c6d}`, []), [value("i32", 357)]);
+
+// ./test/core/names.wast:973
+assert_return(() => invoke($2, `\u{39b}`, []), [value("i32", 358)]);
+
+// ./test/core/names.wast:974
+assert_return(() => invoke($2, `\u{2c70}`, []), [value("i32", 359)]);
+
+// ./test/core/names.wast:975
+assert_return(() => invoke($2, `\u{aa}`, []), [value("i32", 360)]);
+
+// ./test/core/names.wast:976
+assert_return(() => invoke($2, `\u{2200}`, []), [value("i32", 361)]);
+
+// ./test/core/names.wast:977
+assert_return(() => invoke($2, `\u{20b3}`, []), [value("i32", 362)]);
+
+// ./test/core/names.wast:978
+assert_return(() => invoke($2, `\u{10900}`, []), [value("i32", 363)]);
+
+// ./test/core/names.wast:979
+assert_return(() => invoke($2, `\u{2c80}`, []), [value("i32", 364)]);
+
+// ./test/core/names.wast:980
+assert_return(() => invoke($2, `\u{10330}`, []), [value("i32", 365)]);
+
+// ./test/core/names.wast:981
+assert_return(() => invoke($2, `\u{386}`, []), [value("i32", 366)]);
+
+// ./test/core/names.wast:982
+assert_return(() => invoke($2, `\u{391}`, []), [value("i32", 367)]);
+
+// ./test/core/names.wast:983
+assert_return(() => invoke($2, `\u{1f08}`, []), [value("i32", 368)]);
+
+// ./test/core/names.wast:984
+assert_return(() => invoke($2, `\u{1f09}`, []), [value("i32", 369)]);
+
+// ./test/core/names.wast:985
+assert_return(() => invoke($2, `\u{1f0a}`, []), [value("i32", 370)]);
+
+// ./test/core/names.wast:986
+assert_return(() => invoke($2, `\u{1f0b}`, []), [value("i32", 371)]);
+
+// ./test/core/names.wast:987
+assert_return(() => invoke($2, `\u{1f0c}`, []), [value("i32", 372)]);
+
+// ./test/core/names.wast:988
+assert_return(() => invoke($2, `\u{1f0d}`, []), [value("i32", 373)]);
+
+// ./test/core/names.wast:989
+assert_return(() => invoke($2, `\u{1f0e}`, []), [value("i32", 374)]);
+
+// ./test/core/names.wast:990
+assert_return(() => invoke($2, `\u{1f0f}`, []), [value("i32", 375)]);
+
+// ./test/core/names.wast:991
+assert_return(() => invoke($2, `\u{1f88}`, []), [value("i32", 376)]);
+
+// ./test/core/names.wast:992
+assert_return(() => invoke($2, `\u{1f89}`, []), [value("i32", 377)]);
+
+// ./test/core/names.wast:993
+assert_return(() => invoke($2, `\u{1f8a}`, []), [value("i32", 378)]);
+
+// ./test/core/names.wast:994
+assert_return(() => invoke($2, `\u{1f8b}`, []), [value("i32", 379)]);
+
+// ./test/core/names.wast:995
+assert_return(() => invoke($2, `\u{1f8c}`, []), [value("i32", 380)]);
+
+// ./test/core/names.wast:996
+assert_return(() => invoke($2, `\u{1f8d}`, []), [value("i32", 381)]);
+
+// ./test/core/names.wast:997
+assert_return(() => invoke($2, `\u{1f8e}`, []), [value("i32", 382)]);
+
+// ./test/core/names.wast:998
+assert_return(() => invoke($2, `\u{1f8f}`, []), [value("i32", 383)]);
+
+// ./test/core/names.wast:999
+assert_return(() => invoke($2, `\u{1fb8}`, []), [value("i32", 384)]);
+
+// ./test/core/names.wast:1000
+assert_return(() => invoke($2, `\u{1fb9}`, []), [value("i32", 385)]);
+
+// ./test/core/names.wast:1001
+assert_return(() => invoke($2, `\u{1fba}`, []), [value("i32", 386)]);
+
+// ./test/core/names.wast:1002
+assert_return(() => invoke($2, `\u{1fbb}`, []), [value("i32", 387)]);
+
+// ./test/core/names.wast:1003
+assert_return(() => invoke($2, `\u{1fbc}`, []), [value("i32", 388)]);
+
+// ./test/core/names.wast:1004
+assert_return(() => invoke($2, `\u{1d6a8}`, []), [value("i32", 389)]);
+
+// ./test/core/names.wast:1005
+assert_return(() => invoke($2, `\u{1d6e2}`, []), [value("i32", 390)]);
+
+// ./test/core/names.wast:1006
+assert_return(() => invoke($2, `\u{1d71c}`, []), [value("i32", 391)]);
+
+// ./test/core/names.wast:1007
+assert_return(() => invoke($2, `\u{1d756}`, []), [value("i32", 392)]);
+
+// ./test/core/names.wast:1008
+assert_return(() => invoke($2, `\u{1d790}`, []), [value("i32", 393)]);
+
+// ./test/core/names.wast:1009
+assert_return(() => invoke($2, `\u{2376}`, []), [value("i32", 394)]);
+
+// ./test/core/names.wast:1010
+assert_return(() => invoke($2, `\u{237a}`, []), [value("i32", 395)]);
+
+// ./test/core/names.wast:1011
+assert_return(() => invoke($2, `\u{2a5c}`, []), [value("i32", 396)]);
+
+// ./test/core/names.wast:1012
+assert_return(() => invoke($2, `\u{15c5}`, []), [value("i32", 397)]);
+
+// ./test/core/names.wast:1013
+assert_return(() => invoke($2, `\u{13aa}`, []), [value("i32", 398)]);
+
+// ./test/core/names.wast:1014
+assert_return(
+  () => invoke($2, `)\u{2fa}\u{2fc}\u{145cf}\u{1d174}\u{1d176}\u{1d178}\u{1d17a}\u{207e}\u{208e}\u{2769}\u{276b}\u{27ef}\u{fd3f}\u{fe36}\u{fe5a}\u{ff09}\u{ff60}\u{e0029}\u{2773}\u{2775}\u{27e7}\u{27e9}\u{27eb}\u{27ed}\u{2988}\u{298a}\u{2996}\u{2e23}\u{2e25}\u{fe18}\u{fe38}\u{fe3a}\u{fe3c}\u{fe3e}\u{fe40}\u{fe42}\u{fe44}\u{fe48}\u{fe5c}\u{fe5e}\u{ff3d}\u{ff5d}\u{ff63}\u{e005d}\u{e007d}\u{bb}\u{2019}\u{201d}\u{203a}\u{276f}`, []),
+  [value("i32", 399)],
+);
+
+// ./test/core/names.wast:1015
+assert_return(
+  () => invoke($2, `(\u{2f9}\u{2fb}\u{145ce}\u{1d173}\u{1d175}\u{1d177}\u{1d179}\u{207d}\u{208d}\u{2768}\u{276a}\u{27ee}\u{fd3e}\u{fe35}\u{fe59}\u{ff08}\u{ff5f}\u{e0028}\u{2772}\u{2774}\u{27e6}\u{27e8}\u{27ea}\u{27ec}\u{2987}\u{2989}\u{2995}\u{2e22}\u{2e24}\u{fe17}\u{fe37}\u{fe39}\u{fe3b}\u{fe3d}\u{fe3f}\u{fe41}\u{fe43}\u{fe47}\u{fe5b}\u{fe5d}\u{ff3b}\u{ff5b}\u{ff62}\u{e005b}\u{e007b}\u{ab}\u{2018}\u{201c}\u{2039}\u{276e}`, []),
+  [value("i32", 400)],
+);
+
+// ./test/core/names.wast:1016
+assert_return(() => invoke($2, `\u{1da8b}\u{1daa4}`, []), [value("i32", 401)]);
+
+// ./test/core/names.wast:1017
+assert_return(() => invoke($2, `\u{1da8b}`, []), [value("i32", 402)]);
+
+// ./test/core/names.wast:1018
+assert_return(() => invoke($2, `\u{bd}`, []), [value("i32", 403)]);
+
+// ./test/core/names.wast:1019
+assert_return(() => invoke($2, `1\u{2044}2`, []), [value("i32", 404)]);
+
+// ./test/core/names.wast:1020
+assert_return(() => invoke($2, `1/2`, []), [value("i32", 405)]);
+
+// ./test/core/names.wast:1021
+assert_return(() => invoke($2, `\u{b73}`, []), [value("i32", 406)]);
+
+// ./test/core/names.wast:1022
+assert_return(() => invoke($2, `\u{d74}`, []), [value("i32", 407)]);
+
+// ./test/core/names.wast:1023
+assert_return(() => invoke($2, `\u{2cfd}`, []), [value("i32", 408)]);
+
+// ./test/core/names.wast:1024
+assert_return(() => invoke($2, `\u{a831}`, []), [value("i32", 409)]);
+
+// ./test/core/names.wast:1025
+assert_return(() => invoke($2, `\u{10141}`, []), [value("i32", 410)]);
+
+// ./test/core/names.wast:1026
+assert_return(() => invoke($2, `\u{10175}`, []), [value("i32", 411)]);
+
+// ./test/core/names.wast:1027
+assert_return(() => invoke($2, `\u{10176}`, []), [value("i32", 412)]);
+
+// ./test/core/names.wast:1028
+assert_return(() => invoke($2, `\u{109bd}`, []), [value("i32", 413)]);
+
+// ./test/core/names.wast:1029
+assert_return(() => invoke($2, `\u{10e7b}`, []), [value("i32", 414)]);
+
+// ./test/core/names.wast:1030
+assert_return(() => invoke($2, `\u{ff02}`, []), [value("i32", 415)]);
+
+// ./test/core/names.wast:1031
+assert_return(() => invoke($2, `\x7f`, []), [value("i32", 416)]);
+
+// ./test/core/names.wast:1032
+assert_return(() => invoke($2, `\x08`, []), [value("i32", 417)]);
+
+// ./test/core/names.wast:1033
+assert_return(() => invoke($2, `\u{232b}`, []), [value("i32", 418)]);
+
+// ./test/core/names.wast:1034
+assert_return(() => invoke($2, `\u{2326}`, []), [value("i32", 419)]);
+
+// ./test/core/names.wast:1035
+assert_return(() => invoke($2, `\u{2408}`, []), [value("i32", 420)]);
+
+// ./test/core/names.wast:1036
+assert_return(() => invoke($2, `\u{2421}`, []), [value("i32", 421)]);
+
+// ./test/core/names.wast:1037
+assert_return(() => invoke($2, `\u{1dfb}`, []), [value("i32", 422)]);
+
+// ./test/core/names.wast:1038
+assert_return(() => invoke($2, `\x0f`, []), [value("i32", 423)]);
+
+// ./test/core/names.wast:1039
+assert_return(() => invoke($2, `\u{2190}`, []), [value("i32", 424)]);
+
+// ./test/core/names.wast:1040
+assert_return(() => invoke($2, `\u{2327}`, []), [value("i32", 425)]);
+
+// ./test/core/names.wast:1041
+assert_return(() => invoke($2, `\u{2352}`, []), [value("i32", 426)]);
+
+// ./test/core/names.wast:1042
+assert_return(() => invoke($2, `\u{2354}`, []), [value("i32", 427)]);
+
+// ./test/core/names.wast:1043
+assert_return(() => invoke($2, `\u{2362}`, []), [value("i32", 428)]);
+
+// ./test/core/names.wast:1044
+assert_return(() => invoke($2, `\u{236b}`, []), [value("i32", 429)]);
+
+// ./test/core/names.wast:1045
+assert_return(() => invoke($2, `\x1a`, []), [value("i32", 430)]);
+
+// ./test/core/names.wast:1046
+assert_return(() => invoke($2, `\u{2426}`, []), [value("i32", 431)]);
+
+// ./test/core/names.wast:1047
+assert_return(() => invoke($2, `\u{241a}`, []), [value("i32", 432)]);
+
+// ./test/core/names.wast:1048
+assert_return(() => invoke($2, `\u{fffc}`, []), [value("i32", 433)]);
+
+// ./test/core/names.wast:1049
+assert_return(() => invoke($2, `?`, []), [value("i32", 434)]);
+
+// ./test/core/names.wast:1050
+assert_return(() => invoke($2, `\u{bf}`, []), [value("i32", 435)]);
+
+// ./test/core/names.wast:1051
+assert_return(() => invoke($2, `\u{1945}`, []), [value("i32", 436)]);
+
+// ./test/core/names.wast:1052
+assert_return(() => invoke($2, `\u{37e}`, []), [value("i32", 437)]);
+
+// ./test/core/names.wast:1053
+assert_return(() => invoke($2, `\u{55e}`, []), [value("i32", 438)]);
+
+// ./test/core/names.wast:1054
+assert_return(() => invoke($2, `\u{61f}`, []), [value("i32", 439)]);
+
+// ./test/core/names.wast:1055
+assert_return(() => invoke($2, `\u{1367}`, []), [value("i32", 440)]);
+
+// ./test/core/names.wast:1056
+assert_return(() => invoke($2, `\u{2047}`, []), [value("i32", 441)]);
+
+// ./test/core/names.wast:1057
+assert_return(() => invoke($2, `\u{2370}`, []), [value("i32", 442)]);
+
+// ./test/core/names.wast:1058
+assert_return(() => invoke($2, `\u{2753}`, []), [value("i32", 443)]);
+
+// ./test/core/names.wast:1059
+assert_return(() => invoke($2, `\u{2754}`, []), [value("i32", 444)]);
+
+// ./test/core/names.wast:1060
+assert_return(() => invoke($2, `\u{2cfa}`, []), [value("i32", 445)]);
+
+// ./test/core/names.wast:1061
+assert_return(() => invoke($2, `\u{2cfb}`, []), [value("i32", 446)]);
+
+// ./test/core/names.wast:1062
+assert_return(() => invoke($2, `\u{2e2e}`, []), [value("i32", 447)]);
+
+// ./test/core/names.wast:1063
+assert_return(() => invoke($2, `\u{3244}`, []), [value("i32", 448)]);
+
+// ./test/core/names.wast:1064
+assert_return(() => invoke($2, `\u{a60f}`, []), [value("i32", 449)]);
+
+// ./test/core/names.wast:1065
+assert_return(() => invoke($2, `\u{a6f7}`, []), [value("i32", 450)]);
+
+// ./test/core/names.wast:1066
+assert_return(() => invoke($2, `\u{fe16}`, []), [value("i32", 451)]);
+
+// ./test/core/names.wast:1067
+assert_return(() => invoke($2, `\u{fe56}`, []), [value("i32", 452)]);
+
+// ./test/core/names.wast:1068
+assert_return(() => invoke($2, `\u{ff1f}`, []), [value("i32", 453)]);
+
+// ./test/core/names.wast:1069
+assert_return(() => invoke($2, `\u{11143}`, []), [value("i32", 454)]);
+
+// ./test/core/names.wast:1070
+assert_return(() => invoke($2, `\u{1e95f}`, []), [value("i32", 455)]);
+
+// ./test/core/names.wast:1071
+assert_return(() => invoke($2, `\u{e003f}`, []), [value("i32", 456)]);
+
+// ./test/core/names.wast:1072
+assert_return(() => invoke($2, `\u{16844}`, []), [value("i32", 457)]);
+
+// ./test/core/names.wast:1073
+assert_return(() => invoke($2, `\u{2bd1}`, []), [value("i32", 458)]);
+
+// ./test/core/names.wast:1074
+assert_return(() => invoke($2, `\u{b6}`, []), [value("i32", 459)]);
+
+// ./test/core/names.wast:1075
+assert_return(() => invoke($2, `\u{204b}`, []), [value("i32", 460)]);
+
+// ./test/core/names.wast:1076
+assert_return(() => invoke($2, `\u{700}`, []), [value("i32", 461)]);
+
+// ./test/core/names.wast:1077
+assert_return(() => invoke($2, `\u{10fb}`, []), [value("i32", 462)]);
+
+// ./test/core/names.wast:1078
+assert_return(() => invoke($2, `\u{1368}`, []), [value("i32", 463)]);
+
+// ./test/core/names.wast:1079
+assert_return(() => invoke($2, `\u{3037}`, []), [value("i32", 464)]);
+
+// ./test/core/names.wast:1080
+assert_return(() => invoke($2, `\u{2761}`, []), [value("i32", 465)]);
+
+// ./test/core/names.wast:1081
+assert_return(() => invoke($2, `\u{2e0f}`, []), [value("i32", 466)]);
+
+// ./test/core/names.wast:1082
+assert_return(() => invoke($2, `\u{2e10}`, []), [value("i32", 467)]);
+
+// ./test/core/names.wast:1083
+assert_return(() => invoke($2, `\u{2e11}`, []), [value("i32", 468)]);
+
+// ./test/core/names.wast:1084
+assert_return(() => invoke($2, `\u{2e0e}`, []), [value("i32", 469)]);
+
+// ./test/core/names.wast:1085
+assert_return(() => invoke($2, `\x14`, []), [value("i32", 470)]);
+
+// ./test/core/names.wast:1086
+assert_return(() => invoke($2, `\u{2619}`, []), [value("i32", 471)]);
+
+// ./test/core/names.wast:1087
+assert_return(() => invoke($2, `\u{2e3f}`, []), [value("i32", 472)]);
+
+// ./test/core/names.wast:1088
+assert_return(() => invoke($2, `\u{3007}`, []), [value("i32", 473)]);
+
+// ./test/core/names.wast:1089
+assert_return(() => invoke($2, `\u{e5b}`, []), [value("i32", 474)]);
+
+// ./test/core/names.wast:1090
+assert_return(() => invoke($2, `\u{a66e}`, []), [value("i32", 475)]);
+
+// ./test/core/names.wast:1091
+assert_return(() => invoke($2, `\u{3d3}`, []), [value("i32", 476)]);
+
+// ./test/core/names.wast:1092
+assert_return(() => invoke($2, `\u{3d4}`, []), [value("i32", 477)]);
+
+// ./test/core/names.wast:1093
+assert_return(() => invoke($2, `\u{1e9b}`, []), [value("i32", 478)]);
+
+// ./test/core/names.wast:1095
+let $3 = instantiate(`(module
+  ;; Test that we can use indices instead of names to reference imports,
+  ;; exports, functions and parameters.
+  (import "spectest" "print_i32" (func (param i32)))
+  (func (import "spectest" "print_i32") (param i32))
+  (func (param i32) (param i32)
+    (call 0 (local.get 0))
+    (call 1 (local.get 1))
+  )
+  (export "print32" (func 2))
+)`);
+
+// ./test/core/names.wast:1107
+assert_return(() => invoke($3, `print32`, [42, 123]), []);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/nop.wast.js b/js/src/jit-test/tests/wasm/spec/spec/nop.wast.js
new file mode 100644
index 0000000000..c736361363
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/nop.wast.js
@@ -0,0 +1,593 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/nop.wast
+
+// ./test/core/nop.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definitions
+  (func $$dummy)
+  (func $$3-ary (param i32 i32 i32) (result i32)
+    local.get 0 local.get 1 local.get 2 i32.sub i32.add
+  )
+  (memory 1)
+
+  (func (export "as-func-first") (result i32)
+    (nop) (i32.const 1)
+  )
+  (func (export "as-func-mid") (result i32)
+    (call $$dummy) (nop) (i32.const 2)
+  )
+  (func (export "as-func-last") (result i32)
+    (call $$dummy) (i32.const 3) (nop)
+  )
+  (func (export "as-func-everywhere") (result i32)
+    (nop) (nop) (call $$dummy) (nop) (i32.const 4) (nop) (nop)
+  )
+
+  (func (export "as-drop-first") (param i32)
+    (nop) (local.get 0) (drop)
+  )
+  (func (export "as-drop-last") (param i32)
+    (local.get 0) (nop) (drop)
+  )
+  (func (export "as-drop-everywhere") (param i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (drop)
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (nop) (local.get 0) (local.get 0) (local.get 0) (select)
+  )
+  (func (export "as-select-mid1") (param i32) (result i32)
+    (local.get 0) (nop) (local.get 0) (local.get 0) (select)
+  )
+  (func (export "as-select-mid2") (param i32) (result i32)
+    (local.get 0) (local.get 0) (nop) (local.get 0) (select)
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (local.get 0) (local.get 0) (local.get 0) (nop) (select)
+  )
+  (func (export "as-select-everywhere") (param i32) (result i32)
+    (nop) (local.get 0) (nop) (nop) (local.get 0)
+    (nop) (nop) (local.get 0) (nop) (nop) (select)
+  )
+
+  (func (export "as-block-first") (result i32)
+    (block (result i32) (nop) (i32.const 2))
+  )
+  (func (export "as-block-mid") (result i32)
+    (block (result i32) (call $$dummy) (nop) (i32.const 2))
+  )
+  (func (export "as-block-last") (result i32)
+    (block (result i32) (nop) (call $$dummy) (i32.const 3) (nop))
+  )
+  (func (export "as-block-everywhere") (result i32)
+    (block (result i32)
+      (nop) (nop) (call $$dummy) (nop) (i32.const 4) (nop) (nop)
+    )
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (nop) (i32.const 2))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $$dummy) (nop) (i32.const 2))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (call $$dummy) (i32.const 3) (nop))
+  )
+  (func (export "as-loop-everywhere") (result i32)
+    (loop (result i32)
+      (nop) (nop) (call $$dummy) (nop) (i32.const 4) (nop) (nop)
+    )
+  )
+
+  (func (export "as-if-condition") (param i32)
+    (local.get 0) (nop) (if (then (call $$dummy)))
+  )
+  (func (export "as-if-then") (param i32)
+    (if (local.get 0) (then (nop)) (else (call $$dummy)))
+  )
+  (func (export "as-if-else") (param i32)
+    (if (local.get 0) (then (call $$dummy)) (else (nop)))
+  )
+
+  (func (export "as-br-first") (param i32) (result i32)
+    (block (result i32) (nop) (local.get 0) (br 0))
+  )
+  (func (export "as-br-last") (param i32) (result i32)
+    (block (result i32) (local.get 0) (nop) (br 0))
+  )
+  (func (export "as-br-everywhere") (param i32) (result i32)
+    (block (result i32) (nop) (nop) (local.get 0) (nop) (nop) (br 0))
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (nop) (local.get 0) (local.get 0) (br_if 0))
+  )
+  (func (export "as-br_if-mid") (param i32) (result i32)
+    (block (result i32) (local.get 0) (nop) (local.get 0) (br_if 0))
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32) (local.get 0) (local.get 0) (nop) (br_if 0))
+  )
+  (func (export "as-br_if-everywhere") (param i32) (result i32)
+    (block (result i32)
+      (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop)
+      (br_if 0)
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (nop) (local.get 0) (local.get 0) (br_table 0 0))
+  )
+  (func (export "as-br_table-mid") (param i32) (result i32)
+    (block (result i32) (local.get 0) (nop) (local.get 0) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32) (local.get 0) (local.get 0) (nop) (br_table 0 0))
+  )
+  (func (export "as-br_table-everywhere") (param i32) (result i32)
+    (block (result i32)
+      (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop)
+      (br_table 0 0)
+    )
+  )
+
+  (func (export "as-return-first") (param i32) (result i32)
+    (nop) (local.get 0) (return)
+  )
+  (func (export "as-return-last") (param i32) (result i32)
+    (local.get 0) (nop) (return)
+  )
+  (func (export "as-return-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (return)
+  )
+
+  (func (export "as-call-first") (param i32 i32 i32) (result i32)
+    (nop) (local.get 0) (local.get 1) (local.get 2) (call $$3-ary)
+  )
+  (func (export "as-call-mid1") (param i32 i32 i32) (result i32)
+    (local.get 0) (nop) (local.get 1) (local.get 2) (call $$3-ary)
+  )
+  (func (export "as-call-mid2") (param i32 i32 i32) (result i32)
+    (local.get 0) (local.get 1) (nop) (local.get 2) (call $$3-ary)
+  )
+  (func (export "as-call-last") (param i32 i32 i32) (result i32)
+    (local.get 0) (local.get 1) (local.get 2) (nop) (call $$3-ary)
+  )
+  (func (export "as-call-everywhere") (param i32 i32 i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (local.get 1)
+    (nop) (nop) (local.get 2) (nop) (nop) (call $$3-ary)
+  )
+
+  (func (export "as-unary-first") (param i32) (result i32)
+    (nop) (local.get 0) (i32.ctz)
+  )
+  (func (export "as-unary-last") (param i32) (result i32)
+    (local.get 0) (nop) (i32.ctz)
+  )
+  (func (export "as-unary-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (i32.ctz)
+  )
+
+  (func (export "as-binary-first") (param i32) (result i32)
+    (nop) (local.get 0) (local.get 0) (i32.add)
+  )
+  (func (export "as-binary-mid") (param i32) (result i32)
+    (local.get 0) (nop) (local.get 0) (i32.add)
+  )
+  (func (export "as-binary-last") (param i32) (result i32)
+    (local.get 0) (local.get 0) (nop) (i32.add)
+  )
+  (func (export "as-binary-everywhere") (param i32) (result i32)
+    (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.add)
+  )
+
+  (func (export "as-test-first") (param i32) (result i32)
+    (nop) (local.get 0) (i32.eqz)
+  )
+  (func (export "as-test-last") (param i32) (result i32)
+    (local.get 0) (nop) (i32.eqz)
+  )
+  (func (export "as-test-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) i32.eqz
+  )
+
+  (func (export "as-compare-first") (param i32) (result i32)
+    (nop) (local.get 0) (local.get 0) (i32.ne)
+  )
+  (func (export "as-compare-mid") (param i32) (result i32)
+    (local.get 0) (nop) (local.get 0) (i32.ne)
+  )
+  (func (export "as-compare-last") (param i32) (result i32)
+    (local.get 0) (local.get 0) (nop) (i32.lt_u)
+  )
+  (func (export "as-compare-everywhere") (param i32) (result i32)
+    (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.le_s)
+  )
+
+  (func (export "as-memory.grow-first") (param i32) (result i32)
+    (nop) (local.get 0) (memory.grow)
+  )
+  (func (export "as-memory.grow-last") (param i32) (result i32)
+    (local.get 0) (nop) (memory.grow)
+  )
+  (func (export "as-memory.grow-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (memory.grow)
+  )
+
+  (func $$func (param i32 i32) (result i32) (local.get 0))
+  (type $$check (func (param i32 i32) (result i32)))
+  (table funcref (elem $$func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (nop) (i32.const 1) (i32.const 2) (i32.const 0)
+      (call_indirect (type $$check))
+    )
+  )
+  (func (export "as-call_indirect-mid1") (result i32)
+    (block (result i32)
+      (i32.const 1) (nop) (i32.const 2) (i32.const 0)
+      (call_indirect (type $$check))
+    )
+  )
+  (func (export "as-call_indirect-mid2") (result i32)
+    (block (result i32)
+      (i32.const 1) (i32.const 2) (nop) (i32.const 0)
+      (call_indirect (type $$check))
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (i32.const 1) (i32.const 2) (i32.const 0) (nop)
+      (call_indirect (type $$check))
+    )
+  )
+  (func (export "as-call_indirect-everywhere") (result i32)
+    (block (result i32)
+      (nop) (nop) (i32.const 1) (nop) (nop) (i32.const 2) (nop) (nop) (i32.const 0) (nop) (nop)
+      (call_indirect (type $$check))
+    )
+  )
+
+  (func (export "as-local.set-first") (param i32) (result i32)
+    (nop) (i32.const 2) (local.set 0) (local.get 0)
+  )
+  (func (export "as-local.set-last") (param i32) (result i32)
+    (i32.const 2) (nop) (local.set 0) (local.get 0)
+  )
+  (func (export "as-local.set-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (local.set 0) (local.get 0)
+  )
+
+  (func (export "as-local.tee-first") (param i32) (result i32)
+    (nop) (i32.const 2) (local.tee 0)
+  )
+  (func (export "as-local.tee-last") (param i32) (result i32)
+    (i32.const 2) (nop) (local.tee 0)
+  )
+  (func (export "as-local.tee-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (local.tee 0)
+  )
+
+  (global $$a (mut i32) (i32.const 0))
+  (func (export "as-global.set-first") (result i32)
+    (nop) (i32.const 2) (global.set $$a) (global.get $$a)
+  )
+  (func (export "as-global.set-last") (result i32)
+    (i32.const 2) (nop) (global.set $$a) (global.get $$a)
+  )
+  (func (export "as-global.set-everywhere") (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (global.set 0)
+    (global.get $$a)
+  )
+
+  (func (export "as-load-first") (param i32) (result i32)
+    (nop) (local.get 0) (i32.load)
+  )
+  (func (export "as-load-last") (param i32) (result i32)
+    (local.get 0) (nop) (i32.load)
+  )
+  (func (export "as-load-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (i32.load)
+  )
+
+  (func (export "as-store-first") (param i32 i32)
+    (nop) (local.get 0) (local.get 1) (i32.store)
+  )
+  (func (export "as-store-mid") (param i32 i32)
+    (local.get 0) (nop) (local.get 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32 i32)
+    (local.get 0) (local.get 1) (nop) (i32.store)
+  )
+  (func (export "as-store-everywhere") (param i32 i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (local.get 1) (nop) (nop) (i32.store)
+  )
+)`);
+
+// ./test/core/nop.wast:306
+assert_return(() => invoke($0, `as-func-first`, []), [value("i32", 1)]);
+
+// ./test/core/nop.wast:307
+assert_return(() => invoke($0, `as-func-mid`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:308
+assert_return(() => invoke($0, `as-func-last`, []), [value("i32", 3)]);
+
+// ./test/core/nop.wast:309
+assert_return(() => invoke($0, `as-func-everywhere`, []), [value("i32", 4)]);
+
+// ./test/core/nop.wast:311
+assert_return(() => invoke($0, `as-drop-first`, [0]), []);
+
+// ./test/core/nop.wast:312
+assert_return(() => invoke($0, `as-drop-last`, [0]), []);
+
+// ./test/core/nop.wast:313
+assert_return(() => invoke($0, `as-drop-everywhere`, [0]), []);
+
+// ./test/core/nop.wast:315
+assert_return(() => invoke($0, `as-select-first`, [3]), [value("i32", 3)]);
+
+// ./test/core/nop.wast:316
+assert_return(() => invoke($0, `as-select-mid1`, [3]), [value("i32", 3)]);
+
+// ./test/core/nop.wast:317
+assert_return(() => invoke($0, `as-select-mid2`, [3]), [value("i32", 3)]);
+
+// ./test/core/nop.wast:318
+assert_return(() => invoke($0, `as-select-last`, [3]), [value("i32", 3)]);
+
+// ./test/core/nop.wast:319
+assert_return(() => invoke($0, `as-select-everywhere`, [3]), [value("i32", 3)]);
+
+// ./test/core/nop.wast:321
+assert_return(() => invoke($0, `as-block-first`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:322
+assert_return(() => invoke($0, `as-block-mid`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:323
+assert_return(() => invoke($0, `as-block-last`, []), [value("i32", 3)]);
+
+// ./test/core/nop.wast:324
+assert_return(() => invoke($0, `as-block-everywhere`, []), [value("i32", 4)]);
+
+// ./test/core/nop.wast:326
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:327
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:328
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 3)]);
+
+// ./test/core/nop.wast:329
+assert_return(() => invoke($0, `as-loop-everywhere`, []), [value("i32", 4)]);
+
+// ./test/core/nop.wast:331
+assert_return(() => invoke($0, `as-if-condition`, [0]), []);
+
+// ./test/core/nop.wast:332
+assert_return(() => invoke($0, `as-if-condition`, [-1]), []);
+
+// ./test/core/nop.wast:333
+assert_return(() => invoke($0, `as-if-then`, [0]), []);
+
+// ./test/core/nop.wast:334
+assert_return(() => invoke($0, `as-if-then`, [4]), []);
+
+// ./test/core/nop.wast:335
+assert_return(() => invoke($0, `as-if-else`, [0]), []);
+
+// ./test/core/nop.wast:336
+assert_return(() => invoke($0, `as-if-else`, [3]), []);
+
+// ./test/core/nop.wast:338
+assert_return(() => invoke($0, `as-br-first`, [5]), [value("i32", 5)]);
+
+// ./test/core/nop.wast:339
+assert_return(() => invoke($0, `as-br-last`, [6]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:340
+assert_return(() => invoke($0, `as-br-everywhere`, [7]), [value("i32", 7)]);
+
+// ./test/core/nop.wast:342
+assert_return(() => invoke($0, `as-br_if-first`, [4]), [value("i32", 4)]);
+
+// ./test/core/nop.wast:343
+assert_return(() => invoke($0, `as-br_if-mid`, [5]), [value("i32", 5)]);
+
+// ./test/core/nop.wast:344
+assert_return(() => invoke($0, `as-br_if-last`, [6]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:345
+assert_return(() => invoke($0, `as-br_if-everywhere`, [7]), [value("i32", 7)]);
+
+// ./test/core/nop.wast:347
+assert_return(() => invoke($0, `as-br_table-first`, [4]), [value("i32", 4)]);
+
+// ./test/core/nop.wast:348
+assert_return(() => invoke($0, `as-br_table-mid`, [5]), [value("i32", 5)]);
+
+// ./test/core/nop.wast:349
+assert_return(() => invoke($0, `as-br_table-last`, [6]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:350
+assert_return(() => invoke($0, `as-br_table-everywhere`, [7]), [value("i32", 7)]);
+
+// ./test/core/nop.wast:352
+assert_return(() => invoke($0, `as-return-first`, [5]), [value("i32", 5)]);
+
+// ./test/core/nop.wast:353
+assert_return(() => invoke($0, `as-return-last`, [6]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:354
+assert_return(() => invoke($0, `as-return-everywhere`, [7]), [value("i32", 7)]);
+
+// ./test/core/nop.wast:356
+assert_return(() => invoke($0, `as-call-first`, [3, 1, 2]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:357
+assert_return(() => invoke($0, `as-call-mid1`, [3, 1, 2]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:358
+assert_return(() => invoke($0, `as-call-mid2`, [0, 3, 1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:359
+assert_return(() => invoke($0, `as-call-last`, [10, 9, -1]), [value("i32", 20)]);
+
+// ./test/core/nop.wast:360
+assert_return(() => invoke($0, `as-call-everywhere`, [2, 1, 5]), [value("i32", -2)]);
+
+// ./test/core/nop.wast:362
+assert_return(() => invoke($0, `as-unary-first`, [30]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:363
+assert_return(() => invoke($0, `as-unary-last`, [30]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:364
+assert_return(() => invoke($0, `as-unary-everywhere`, [12]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:366
+assert_return(() => invoke($0, `as-binary-first`, [3]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:367
+assert_return(() => invoke($0, `as-binary-mid`, [3]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:368
+assert_return(() => invoke($0, `as-binary-last`, [3]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:369
+assert_return(() => invoke($0, `as-binary-everywhere`, [3]), [value("i32", 6)]);
+
+// ./test/core/nop.wast:371
+assert_return(() => invoke($0, `as-test-first`, [0]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:372
+assert_return(() => invoke($0, `as-test-last`, [0]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:373
+assert_return(() => invoke($0, `as-test-everywhere`, [0]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:375
+assert_return(() => invoke($0, `as-compare-first`, [3]), [value("i32", 0)]);
+
+// ./test/core/nop.wast:376
+assert_return(() => invoke($0, `as-compare-mid`, [3]), [value("i32", 0)]);
+
+// ./test/core/nop.wast:377
+assert_return(() => invoke($0, `as-compare-last`, [3]), [value("i32", 0)]);
+
+// ./test/core/nop.wast:378
+assert_return(() => invoke($0, `as-compare-everywhere`, [3]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:380
+assert_return(() => invoke($0, `as-memory.grow-first`, [0]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:381
+assert_return(() => invoke($0, `as-memory.grow-last`, [2]), [value("i32", 1)]);
+
+// ./test/core/nop.wast:382
+assert_return(() => invoke($0, `as-memory.grow-everywhere`, [12]), [value("i32", 3)]);
+
+// ./test/core/nop.wast:384
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 1)]);
+
+// ./test/core/nop.wast:385
+assert_return(() => invoke($0, `as-call_indirect-mid1`, []), [value("i32", 1)]);
+
+// ./test/core/nop.wast:386
+assert_return(() => invoke($0, `as-call_indirect-mid2`, []), [value("i32", 1)]);
+
+// ./test/core/nop.wast:387
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 1)]);
+
+// ./test/core/nop.wast:388
+assert_return(() => invoke($0, `as-call_indirect-everywhere`, []), [value("i32", 1)]);
+
+// ./test/core/nop.wast:390
+assert_return(() => invoke($0, `as-local.set-first`, [1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:391
+assert_return(() => invoke($0, `as-local.set-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:392
+assert_return(() => invoke($0, `as-local.set-everywhere`, [1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:394
+assert_return(() => invoke($0, `as-local.tee-first`, [1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:395
+assert_return(() => invoke($0, `as-local.tee-last`, [1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:396
+assert_return(() => invoke($0, `as-local.tee-everywhere`, [1]), [value("i32", 2)]);
+
+// ./test/core/nop.wast:398
+assert_return(() => invoke($0, `as-global.set-first`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:399
+assert_return(() => invoke($0, `as-global.set-last`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:400
+assert_return(() => invoke($0, `as-global.set-everywhere`, []), [value("i32", 2)]);
+
+// ./test/core/nop.wast:402
+assert_return(() => invoke($0, `as-load-first`, [100]), [value("i32", 0)]);
+
+// ./test/core/nop.wast:403
+assert_return(() => invoke($0, `as-load-last`, [100]), [value("i32", 0)]);
+
+// ./test/core/nop.wast:404
+assert_return(() => invoke($0, `as-load-everywhere`, [100]), [value("i32", 0)]);
+
+// ./test/core/nop.wast:406
+assert_return(() => invoke($0, `as-store-first`, [0, 1]), []);
+
+// ./test/core/nop.wast:407
+assert_return(() => invoke($0, `as-store-mid`, [0, 2]), []);
+
+// ./test/core/nop.wast:408
+assert_return(() => invoke($0, `as-store-last`, [0, 3]), []);
+
+// ./test/core/nop.wast:409
+assert_return(() => invoke($0, `as-store-everywhere`, [0, 4]), []);
+
+// ./test/core/nop.wast:411
+assert_invalid(
+  () => instantiate(`(module (func $$type-i32 (result i32) (nop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/nop.wast:415
+assert_invalid(
+  () => instantiate(`(module (func $$type-i64 (result i64) (nop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/nop.wast:419
+assert_invalid(
+  () => instantiate(`(module (func $$type-f32 (result f32) (nop)))`),
+  `type mismatch`,
+);
+
+// ./test/core/nop.wast:423
+assert_invalid(
+  () => instantiate(`(module (func $$type-f64 (result f64) (nop)))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/ref_func.wast.js b/js/src/jit-test/tests/wasm/spec/spec/ref_func.wast.js
new file mode 100644
index 0000000000..3ca5cea002
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/ref_func.wast.js
@@ -0,0 +1,156 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/ref_func.wast
+
+// ./test/core/ref_func.wast:1
+let $0 = instantiate(`(module
+  (func (export "f") (param $$x i32) (result i32) (local.get $$x))
+)`);
+
+// ./test/core/ref_func.wast:4
+register($0, `M`);
+
+// ./test/core/ref_func.wast:6
+let $1 = instantiate(`(module
+  (func $$f (import "M" "f") (param i32) (result i32))
+  (func $$g (param $$x i32) (result i32)
+    (i32.add (local.get $$x) (i32.const 1))
+  )
+
+  (global funcref (ref.func $$f))
+  (global funcref (ref.func $$g))
+  (global $$v (mut funcref) (ref.func $$f))
+
+  (global funcref (ref.func $$gf1))
+  (global funcref (ref.func $$gf2))
+  (func (drop (ref.func $$ff1)) (drop (ref.func $$ff2)))
+  (elem declare func $$gf1 $$ff1)
+  (elem declare funcref (ref.func $$gf2) (ref.func $$ff2))
+  (func $$gf1)
+  (func $$gf2)
+  (func $$ff1)
+  (func $$ff2)
+
+  (func (export "is_null-f") (result i32)
+    (ref.is_null (ref.func $$f))
+  )
+  (func (export "is_null-g") (result i32)
+    (ref.is_null (ref.func $$g))
+  )
+  (func (export "is_null-v") (result i32)
+    (ref.is_null (global.get $$v))
+  )
+
+  (func (export "set-f") (global.set $$v (ref.func $$f)))
+  (func (export "set-g") (global.set $$v (ref.func $$g)))
+
+  (table $$t 1 funcref)
+  (elem declare func $$f $$g)
+
+  (func (export "call-f") (param $$x i32) (result i32)
+    (table.set $$t (i32.const 0) (ref.func $$f))
+    (call_indirect $$t (param i32) (result i32) (local.get $$x) (i32.const 0))
+  )
+  (func (export "call-g") (param $$x i32) (result i32)
+    (table.set $$t (i32.const 0) (ref.func $$g))
+    (call_indirect $$t (param i32) (result i32) (local.get $$x) (i32.const 0))
+  )
+  (func (export "call-v") (param $$x i32) (result i32)
+    (table.set $$t (i32.const 0) (global.get $$v))
+    (call_indirect $$t (param i32) (result i32) (local.get $$x) (i32.const 0))
+  )
+)`);
+
+// ./test/core/ref_func.wast:56
+assert_return(() => invoke($1, `is_null-f`, []), [value("i32", 0)]);
+
+// ./test/core/ref_func.wast:57
+assert_return(() => invoke($1, `is_null-g`, []), [value("i32", 0)]);
+
+// ./test/core/ref_func.wast:58
+assert_return(() => invoke($1, `is_null-v`, []), [value("i32", 0)]);
+
+// ./test/core/ref_func.wast:60
+assert_return(() => invoke($1, `call-f`, [4]), [value("i32", 4)]);
+
+// ./test/core/ref_func.wast:61
+assert_return(() => invoke($1, `call-g`, [4]), [value("i32", 5)]);
+
+// ./test/core/ref_func.wast:62
+assert_return(() => invoke($1, `call-v`, [4]), [value("i32", 4)]);
+
+// ./test/core/ref_func.wast:63
+invoke($1, `set-g`, []);
+
+// ./test/core/ref_func.wast:64
+assert_return(() => invoke($1, `call-v`, [4]), [value("i32", 5)]);
+
+// ./test/core/ref_func.wast:65
+invoke($1, `set-f`, []);
+
+// ./test/core/ref_func.wast:66
+assert_return(() => invoke($1, `call-v`, [4]), [value("i32", 4)]);
+
+// ./test/core/ref_func.wast:68
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (import "M" "f") (param i32) (result i32))
+    (func $$g (import "M" "g") (param i32) (result i32))
+    (global funcref (ref.func 7))
+  )`),
+  `unknown function 7`,
+);
+
+// ./test/core/ref_func.wast:80
+let $2 = instantiate(`(module
+  (func $$f1)
+  (func $$f2)
+  (func $$f3)
+  (func $$f4)
+  (func $$f5)
+  (func $$f6)
+
+  (table $$t 1 funcref)
+
+  (global funcref (ref.func $$f1))
+  (export "f" (func $$f2))
+  (elem (table $$t) (i32.const 0) func $$f3)
+  (elem (table $$t) (i32.const 0) funcref (ref.func $$f4))
+  (elem func $$f5)
+  (elem funcref (ref.func $$f6))
+
+  (func
+    (ref.func $$f1)
+    (ref.func $$f2)
+    (ref.func $$f3)
+    (ref.func $$f4)
+    (ref.func $$f5)
+    (ref.func $$f6)
+    (return)
+  )
+)`);
+
+// ./test/core/ref_func.wast:108
+assert_invalid(
+  () => instantiate(`(module (func $$f (drop (ref.func $$f))))`),
+  `undeclared function reference`,
+);
+
+// ./test/core/ref_func.wast:112
+assert_invalid(
+  () => instantiate(`(module (start $$f) (func $$f (drop (ref.func $$f))))`),
+  `undeclared function reference`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/ref_is_null.wast.js b/js/src/jit-test/tests/wasm/spec/spec/ref_is_null.wast.js
new file mode 100644
index 0000000000..2c7aee86e0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/ref_is_null.wast.js
@@ -0,0 +1,97 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/ref_is_null.wast
+
+// ./test/core/ref_is_null.wast:1
+let $0 = instantiate(`(module
+  (func $$f1 (export "funcref") (param $$x funcref) (result i32)
+    (ref.is_null (local.get $$x))
+  )
+  (func $$f2 (export "externref") (param $$x externref) (result i32)
+    (ref.is_null (local.get $$x))
+  )
+
+  (table $$t1 2 funcref)
+  (table $$t2 2 externref)
+  (elem (table $$t1) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "init") (param $$r externref)
+    (table.set $$t2 (i32.const 1) (local.get $$r))
+  )
+  (func (export "deinit")
+    (table.set $$t1 (i32.const 1) (ref.null func))
+    (table.set $$t2 (i32.const 1) (ref.null extern))
+  )
+
+  (func (export "funcref-elem") (param $$x i32) (result i32)
+    (call $$f1 (table.get $$t1 (local.get $$x)))
+  )
+  (func (export "externref-elem") (param $$x i32) (result i32)
+    (call $$f2 (table.get $$t2 (local.get $$x)))
+  )
+)`);
+
+// ./test/core/ref_is_null.wast:30
+assert_return(() => invoke($0, `funcref`, [null]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:31
+assert_return(() => invoke($0, `externref`, [null]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:33
+assert_return(() => invoke($0, `externref`, [externref(1)]), [value("i32", 0)]);
+
+// ./test/core/ref_is_null.wast:35
+invoke($0, `init`, [externref(0)]);
+
+// ./test/core/ref_is_null.wast:37
+assert_return(() => invoke($0, `funcref-elem`, [0]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:38
+assert_return(() => invoke($0, `externref-elem`, [0]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:40
+assert_return(() => invoke($0, `funcref-elem`, [1]), [value("i32", 0)]);
+
+// ./test/core/ref_is_null.wast:41
+assert_return(() => invoke($0, `externref-elem`, [1]), [value("i32", 0)]);
+
+// ./test/core/ref_is_null.wast:43
+invoke($0, `deinit`, []);
+
+// ./test/core/ref_is_null.wast:45
+assert_return(() => invoke($0, `funcref-elem`, [0]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:46
+assert_return(() => invoke($0, `externref-elem`, [0]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:48
+assert_return(() => invoke($0, `funcref-elem`, [1]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:49
+assert_return(() => invoke($0, `externref-elem`, [1]), [value("i32", 1)]);
+
+// ./test/core/ref_is_null.wast:51
+assert_invalid(
+  () => instantiate(`(module (func $$ref-vs-num (param i32) (ref.is_null (local.get 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/ref_is_null.wast:55
+assert_invalid(
+  () => instantiate(`(module (func $$ref-vs-empty (ref.is_null)))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/ref_null.wast.js b/js/src/jit-test/tests/wasm/spec/spec/ref_null.wast.js
new file mode 100644
index 0000000000..bae6ecd4b2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/ref_null.wast.js
@@ -0,0 +1,31 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/ref_null.wast
+
+// ./test/core/ref_null.wast:1
+let $0 = instantiate(`(module
+  (func (export "externref") (result externref) (ref.null extern))
+  (func (export "funcref") (result funcref) (ref.null func))
+
+  (global externref (ref.null extern))
+  (global funcref (ref.null func))
+)`);
+
+// ./test/core/ref_null.wast:9
+assert_return(() => invoke($0, `externref`, []), [value('externref', null)]);
+
+// ./test/core/ref_null.wast:10
+assert_return(() => invoke($0, `funcref`, []), [value('anyfunc', null)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/return.wast.js b/js/src/jit-test/tests/wasm/spec/spec/return.wast.js
new file mode 100644
index 0000000000..7d09ec6a2e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/return.wast.js
@@ -0,0 +1,636 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/return.wast
+
+// ./test/core/return.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definition
+  (func $$dummy)
+
+  (func (export "type-i32") (drop (i32.ctz (return))))
+  (func (export "type-i64") (drop (i64.ctz (return))))
+  (func (export "type-f32") (drop (f32.neg (return))))
+  (func (export "type-f64") (drop (f64.neg (return))))
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (return (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (return (i64.const 2))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (return (f32.const 3))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (return (f64.const 4))))
+  )
+
+  (func (export "nullary") (return))
+  (func (export "unary") (result f64) (return (f64.const 3)))
+
+  (func (export "as-func-first") (result i32)
+    (return (i32.const 1)) (i32.const 2)
+  )
+  (func (export "as-func-mid") (result i32)
+    (call $$dummy) (return (i32.const 2)) (i32.const 3)
+  )
+  (func (export "as-func-last")
+    (nop) (call $$dummy) (return)
+  )
+  (func (export "as-func-value") (result i32)
+    (nop) (call $$dummy) (return (i32.const 3))
+  )
+
+  (func (export "as-block-first")
+    (block (return) (call $$dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $$dummy) (return) (call $$dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $$dummy) (return))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $$dummy) (return (i32.const 2)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (return (i32.const 3)) (i32.const 2))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $$dummy) (return (i32.const 4)) (i32.const 2))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (nop) (call $$dummy) (return (i32.const 5)))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (return (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (return)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (return (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (return (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index") (result i64)
+    (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1)
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (return (return (i64.const 7)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32)
+      (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (if (result i32)
+      (local.get 0) (then (return (i32.const 3))) (else (local.get 1))
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (if (result i32)
+      (local.get 0) (then (local.get 1)) (else (return (i32.const 4)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (return (i32.const 5)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (return (i32.const 6)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (return (i32.const 7)))
+  )
+
+  (func $$f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $$f (return (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $$f (i32.const 1) (return (i32.const 13)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $$f (i32.const 1) (i32.const 2) (return (i32.const 14)))
+  )
+
+  (type $$sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $$f))
+  (func (export "as-call_indirect-func") (result i32)
+    (call_indirect (type $$sig)
+      (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $$sig)
+      (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23))
+    )
+  )
+
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (local.set 0 (return (i32.const 17))) (i32.const -1)
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (return (i32.const 1)))
+  )
+  (global $$a (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $$a (return (i32.const 1)))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (f32.load (return (f32.const 1.7)))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (i64.load8_s (return (i64.const 30)))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (f64.store (return (i32.const 30)) (f64.const 7)) (i32.const -1)
+  )
+  (func (export "as-store-value") (result i32)
+    (i64.store (i32.const 2) (return (i32.const 31))) (i32.const -1)
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (i32.store8 (return (i32.const 32)) (i32.const 7)) (i32.const -1)
+  )
+  (func (export "as-storeN-value") (result i32)
+    (i64.store16 (i32.const 2) (return (i32.const 33))) (i32.const -1)
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (f32.neg (return (f32.const 3.4)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (return (i32.const 3)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i64)
+    (i64.sub (i64.const 10) (return (i64.const 45)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (return (i32.const 44)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (f64.le (return (i32.const 43)) (f64.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (f32.ne (f32.const 10) (return (i32.const 42)))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (i32.wrap_i64 (return (i32.const 41)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (return (i32.const 40)))
+  )
+)`);
+
+// ./test/core/return.wast:224
+assert_return(() => invoke($0, `type-i32`, []), []);
+
+// ./test/core/return.wast:225
+assert_return(() => invoke($0, `type-i64`, []), []);
+
+// ./test/core/return.wast:226
+assert_return(() => invoke($0, `type-f32`, []), []);
+
+// ./test/core/return.wast:227
+assert_return(() => invoke($0, `type-f64`, []), []);
+
+// ./test/core/return.wast:229
+assert_return(() => invoke($0, `type-i32-value`, []), [value("i32", 1)]);
+
+// ./test/core/return.wast:230
+assert_return(() => invoke($0, `type-i64-value`, []), [value("i64", 2n)]);
+
+// ./test/core/return.wast:231
+assert_return(() => invoke($0, `type-f32-value`, []), [value("f32", 3)]);
+
+// ./test/core/return.wast:232
+assert_return(() => invoke($0, `type-f64-value`, []), [value("f64", 4)]);
+
+// ./test/core/return.wast:234
+assert_return(() => invoke($0, `nullary`, []), []);
+
+// ./test/core/return.wast:235
+assert_return(() => invoke($0, `unary`, []), [value("f64", 3)]);
+
+// ./test/core/return.wast:237
+assert_return(() => invoke($0, `as-func-first`, []), [value("i32", 1)]);
+
+// ./test/core/return.wast:238
+assert_return(() => invoke($0, `as-func-mid`, []), [value("i32", 2)]);
+
+// ./test/core/return.wast:239
+assert_return(() => invoke($0, `as-func-last`, []), []);
+
+// ./test/core/return.wast:240
+assert_return(() => invoke($0, `as-func-value`, []), [value("i32", 3)]);
+
+// ./test/core/return.wast:242
+assert_return(() => invoke($0, `as-block-first`, []), []);
+
+// ./test/core/return.wast:243
+assert_return(() => invoke($0, `as-block-mid`, []), []);
+
+// ./test/core/return.wast:244
+assert_return(() => invoke($0, `as-block-last`, []), []);
+
+// ./test/core/return.wast:245
+assert_return(() => invoke($0, `as-block-value`, []), [value("i32", 2)]);
+
+// ./test/core/return.wast:247
+assert_return(() => invoke($0, `as-loop-first`, []), [value("i32", 3)]);
+
+// ./test/core/return.wast:248
+assert_return(() => invoke($0, `as-loop-mid`, []), [value("i32", 4)]);
+
+// ./test/core/return.wast:249
+assert_return(() => invoke($0, `as-loop-last`, []), [value("i32", 5)]);
+
+// ./test/core/return.wast:251
+assert_return(() => invoke($0, `as-br-value`, []), [value("i32", 9)]);
+
+// ./test/core/return.wast:253
+assert_return(() => invoke($0, `as-br_if-cond`, []), []);
+
+// ./test/core/return.wast:254
+assert_return(() => invoke($0, `as-br_if-value`, []), [value("i32", 8)]);
+
+// ./test/core/return.wast:255
+assert_return(() => invoke($0, `as-br_if-value-cond`, []), [value("i32", 9)]);
+
+// ./test/core/return.wast:257
+assert_return(() => invoke($0, `as-br_table-index`, []), [value("i64", 9n)]);
+
+// ./test/core/return.wast:258
+assert_return(() => invoke($0, `as-br_table-value`, []), [value("i32", 10)]);
+
+// ./test/core/return.wast:259
+assert_return(() => invoke($0, `as-br_table-value-index`, []), [value("i32", 11)]);
+
+// ./test/core/return.wast:261
+assert_return(() => invoke($0, `as-return-value`, []), [value("i64", 7n)]);
+
+// ./test/core/return.wast:263
+assert_return(() => invoke($0, `as-if-cond`, []), [value("i32", 2)]);
+
+// ./test/core/return.wast:264
+assert_return(() => invoke($0, `as-if-then`, [1, 6]), [value("i32", 3)]);
+
+// ./test/core/return.wast:265
+assert_return(() => invoke($0, `as-if-then`, [0, 6]), [value("i32", 6)]);
+
+// ./test/core/return.wast:266
+assert_return(() => invoke($0, `as-if-else`, [0, 6]), [value("i32", 4)]);
+
+// ./test/core/return.wast:267
+assert_return(() => invoke($0, `as-if-else`, [1, 6]), [value("i32", 6)]);
+
+// ./test/core/return.wast:269
+assert_return(() => invoke($0, `as-select-first`, [0, 6]), [value("i32", 5)]);
+
+// ./test/core/return.wast:270
+assert_return(() => invoke($0, `as-select-first`, [1, 6]), [value("i32", 5)]);
+
+// ./test/core/return.wast:271
+assert_return(() => invoke($0, `as-select-second`, [0, 6]), [value("i32", 6)]);
+
+// ./test/core/return.wast:272
+assert_return(() => invoke($0, `as-select-second`, [1, 6]), [value("i32", 6)]);
+
+// ./test/core/return.wast:273
+assert_return(() => invoke($0, `as-select-cond`, []), [value("i32", 7)]);
+
+// ./test/core/return.wast:275
+assert_return(() => invoke($0, `as-call-first`, []), [value("i32", 12)]);
+
+// ./test/core/return.wast:276
+assert_return(() => invoke($0, `as-call-mid`, []), [value("i32", 13)]);
+
+// ./test/core/return.wast:277
+assert_return(() => invoke($0, `as-call-last`, []), [value("i32", 14)]);
+
+// ./test/core/return.wast:279
+assert_return(() => invoke($0, `as-call_indirect-func`, []), [value("i32", 20)]);
+
+// ./test/core/return.wast:280
+assert_return(() => invoke($0, `as-call_indirect-first`, []), [value("i32", 21)]);
+
+// ./test/core/return.wast:281
+assert_return(() => invoke($0, `as-call_indirect-mid`, []), [value("i32", 22)]);
+
+// ./test/core/return.wast:282
+assert_return(() => invoke($0, `as-call_indirect-last`, []), [value("i32", 23)]);
+
+// ./test/core/return.wast:284
+assert_return(() => invoke($0, `as-local.set-value`, []), [value("i32", 17)]);
+
+// ./test/core/return.wast:285
+assert_return(() => invoke($0, `as-local.tee-value`, []), [value("i32", 1)]);
+
+// ./test/core/return.wast:286
+assert_return(() => invoke($0, `as-global.set-value`, []), [value("i32", 1)]);
+
+// ./test/core/return.wast:288
+assert_return(() => invoke($0, `as-load-address`, []), [value("f32", 1.7)]);
+
+// ./test/core/return.wast:289
+assert_return(() => invoke($0, `as-loadN-address`, []), [value("i64", 30n)]);
+
+// ./test/core/return.wast:291
+assert_return(() => invoke($0, `as-store-address`, []), [value("i32", 30)]);
+
+// ./test/core/return.wast:292
+assert_return(() => invoke($0, `as-store-value`, []), [value("i32", 31)]);
+
+// ./test/core/return.wast:293
+assert_return(() => invoke($0, `as-storeN-address`, []), [value("i32", 32)]);
+
+// ./test/core/return.wast:294
+assert_return(() => invoke($0, `as-storeN-value`, []), [value("i32", 33)]);
+
+// ./test/core/return.wast:296
+assert_return(() => invoke($0, `as-unary-operand`, []), [value("f32", 3.4)]);
+
+// ./test/core/return.wast:298
+assert_return(() => invoke($0, `as-binary-left`, []), [value("i32", 3)]);
+
+// ./test/core/return.wast:299
+assert_return(() => invoke($0, `as-binary-right`, []), [value("i64", 45n)]);
+
+// ./test/core/return.wast:301
+assert_return(() => invoke($0, `as-test-operand`, []), [value("i32", 44)]);
+
+// ./test/core/return.wast:303
+assert_return(() => invoke($0, `as-compare-left`, []), [value("i32", 43)]);
+
+// ./test/core/return.wast:304
+assert_return(() => invoke($0, `as-compare-right`, []), [value("i32", 42)]);
+
+// ./test/core/return.wast:306
+assert_return(() => invoke($0, `as-convert-operand`, []), [value("i32", 41)]);
+
+// ./test/core/return.wast:308
+assert_return(() => invoke($0, `as-memory.grow-size`, []), [value("i32", 40)]);
+
+// ./test/core/return.wast:310
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-empty-vs-num (result i32) (return)))`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:314
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-block (result i32)
+      (i32.const 0)
+      (block (return))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:323
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-loop (result i32)
+      (i32.const 0)
+      (loop (return))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:332
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-then (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (then (return)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:341
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-else (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (return))) (drop)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:350
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-br (result i32)
+      (i32.const 0)
+      (block (br 0 (return)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:359
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-br_if (result i32)
+      (i32.const 0)
+      (block (br_if 0 (return) (i32.const 1)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:368
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-br_table (result i32)
+      (i32.const 0)
+      (block (br_table 0 (return)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:377
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-return (result i32)
+      (return (return))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:385
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-select (result i32)
+      (select (return) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:393
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-call (result i32)
+      (call 1 (return))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:402
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-value-empty-vs-num-in-call_indirect (result i32)
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (return) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:417
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-local.set (result i32)
+      (local i32)
+      (local.set 0 (return)) (local.get 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:426
+assert_invalid(
+  () => instantiate(`(module
+    (func $$type-value-empty-vs-num-in-local.tee (result i32)
+      (local i32)
+      (local.tee 0 (return))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:435
+assert_invalid(
+  () => instantiate(`(module
+    (global $$x (mut i32) (i32.const 0))
+    (func $$type-value-empty-vs-num-in-global.set (result i32)
+      (global.set $$x (return)) (global.get $$x)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:444
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-value-empty-vs-num-in-memory.grow (result i32)
+      (memory.grow (return))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:453
+assert_invalid(
+  () => instantiate(`(module
+    (memory 0)
+    (func $$type-value-empty-vs-num-in-load (result i32)
+      (i32.load (return))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:462
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-vs-num-in-store (result i32)
+      (i32.store (return) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:471
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-void-vs-num (result f64) (return (nop))))`),
+  `type mismatch`,
+);
+
+// ./test/core/return.wast:475
+assert_invalid(
+  () => instantiate(`(module (func $$type-value-num-vs-num (result f64) (return (i64.const 1))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js
new file mode 100644
index 0000000000..c94be782b9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_address.wast.js
@@ -0,0 +1,348 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_address.wast
+
+// ./test/core/simd/simd_address.wast:3
+let $0 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_address.wast:53
+assert_return(
+  () => invoke($0, `load_data_1`, [0]),
+  [i32x4([0x3020100, 0x7060504, 0x11100908, 0x15141312])],
+);
+
+// ./test/core/simd/simd_address.wast:54
+assert_return(
+  () => invoke($0, `load_data_2`, [0]),
+  [i32x4([0x3020100, 0x7060504, 0x11100908, 0x15141312])],
+);
+
+// ./test/core/simd/simd_address.wast:55
+assert_return(
+  () => invoke($0, `load_data_3`, [0]),
+  [i32x4([0x4030201, 0x8070605, 0x12111009, 0x151413])],
+);
+
+// ./test/core/simd/simd_address.wast:56
+assert_return(() => invoke($0, `load_data_4`, [0]), [i32x4([0x5040302, 0x9080706, 0x13121110, 0x1514])]);
+
+// ./test/core/simd/simd_address.wast:57
+assert_return(() => invoke($0, `load_data_5`, [0]), [i32x4([0x15, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_address.wast:59
+assert_return(
+  () => invoke($0, `load_data_1`, [0]),
+  [i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0x1110, 0x1312, 0x1514])],
+);
+
+// ./test/core/simd/simd_address.wast:60
+assert_return(
+  () => invoke($0, `load_data_2`, [0]),
+  [i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0x1110, 0x1312, 0x1514])],
+);
+
+// ./test/core/simd/simd_address.wast:61
+assert_return(
+  () => invoke($0, `load_data_3`, [0]),
+  [i16x8([0x201, 0x403, 0x605, 0x807, 0x1009, 0x1211, 0x1413, 0x15])],
+);
+
+// ./test/core/simd/simd_address.wast:62
+assert_return(
+  () => invoke($0, `load_data_4`, [0]),
+  [i16x8([0x302, 0x504, 0x706, 0x908, 0x1110, 0x1312, 0x1514, 0x0])],
+);
+
+// ./test/core/simd/simd_address.wast:63
+assert_return(() => invoke($0, `load_data_5`, [0]), [i16x8([0x15, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_address.wast:65
+assert_return(
+  () => invoke($0, `load_data_1`, [0]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:66
+assert_return(
+  () => invoke($0, `load_data_2`, [0]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:67
+assert_return(
+  () => invoke($0, `load_data_3`, [0]),
+  [
+    i8x16([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:68
+assert_return(
+  () => invoke($0, `load_data_4`, [0]),
+  [
+    i8x16([0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:69
+assert_return(
+  () => invoke($0, `load_data_5`, [0]),
+  [
+    i8x16([0x15, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:71
+assert_return(
+  () => invoke($0, `load_data_1`, [65505]),
+  [i32x4([0x19181716, 0x23222120, 0x27262524, 0x31302928])],
+);
+
+// ./test/core/simd/simd_address.wast:72
+assert_return(
+  () => invoke($0, `load_data_2`, [65505]),
+  [i32x4([0x19181716, 0x23222120, 0x27262524, 0x31302928])],
+);
+
+// ./test/core/simd/simd_address.wast:73
+assert_return(
+  () => invoke($0, `load_data_3`, [65505]),
+  [i32x4([0x20191817, 0x24232221, 0x28272625, 0x313029])],
+);
+
+// ./test/core/simd/simd_address.wast:74
+assert_return(
+  () => invoke($0, `load_data_4`, [65505]),
+  [i32x4([0x21201918, 0x25242322, 0x29282726, 0x3130])],
+);
+
+// ./test/core/simd/simd_address.wast:75
+assert_return(() => invoke($0, `load_data_5`, [65505]), [i32x4([0x31, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_address.wast:77
+assert_return(
+  () => invoke($0, `load_data_1`, [65505]),
+  [i16x8([0x1716, 0x1918, 0x2120, 0x2322, 0x2524, 0x2726, 0x2928, 0x3130])],
+);
+
+// ./test/core/simd/simd_address.wast:78
+assert_return(
+  () => invoke($0, `load_data_2`, [65505]),
+  [i16x8([0x1716, 0x1918, 0x2120, 0x2322, 0x2524, 0x2726, 0x2928, 0x3130])],
+);
+
+// ./test/core/simd/simd_address.wast:79
+assert_return(
+  () => invoke($0, `load_data_3`, [65505]),
+  [i16x8([0x1817, 0x2019, 0x2221, 0x2423, 0x2625, 0x2827, 0x3029, 0x31])],
+);
+
+// ./test/core/simd/simd_address.wast:80
+assert_return(
+  () => invoke($0, `load_data_4`, [65505]),
+  [i16x8([0x1918, 0x2120, 0x2322, 0x2524, 0x2726, 0x2928, 0x3130, 0x0])],
+);
+
+// ./test/core/simd/simd_address.wast:81
+assert_return(
+  () => invoke($0, `load_data_5`, [65505]),
+  [i16x8([0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_address.wast:83
+assert_return(
+  () => invoke($0, `load_data_1`, [65505]),
+  [
+    i8x16([0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:84
+assert_return(
+  () => invoke($0, `load_data_2`, [65505]),
+  [
+    i8x16([0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:85
+assert_return(
+  () => invoke($0, `load_data_3`, [65505]),
+  [
+    i8x16([0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:86
+assert_return(
+  () => invoke($0, `load_data_4`, [65505]),
+  [
+    i8x16([0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30, 0x31, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:87
+assert_return(
+  () => invoke($0, `load_data_5`, [65505]),
+  [
+    i8x16([0x31, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:89
+assert_trap(() => invoke($0, `load_data_3`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_address.wast:90
+assert_trap(() => invoke($0, `load_data_5`, [65506]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_address.wast:92
+assert_return(
+  () => invoke($0, `store_data_0`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:93
+assert_return(() => invoke($0, `store_data_1`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_address.wast:94
+assert_return(() => invoke($0, `store_data_2`, []), [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])]);
+
+// ./test/core/simd/simd_address.wast:95
+assert_return(
+  () => invoke($0, `store_data_3`, []),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_address.wast:96
+assert_return(() => invoke($0, `store_data_4`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_address.wast:97
+assert_return(() => invoke($0, `store_data_5`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_address.wast:99
+assert_trap(() => invoke($0, `store_data_6`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_address.wast:100
+assert_trap(() => invoke($0, `store_data_6`, [65535]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_address.wast:104
+let $1 = instantiate(`(module
+  (memory 1)
+  (func (export "v128.load_offset_65521")
+    (drop (v128.load offset=65521 (i32.const 0)))
+  )
+)`);
+
+// ./test/core/simd/simd_address.wast:110
+assert_trap(() => invoke($1, `v128.load_offset_65521`, []), `out of bounds memory access`);
+
+// ./test/core/simd/simd_address.wast:112
+assert_malformed(
+  () => instantiate(`(memory 1) (func   (drop (v128.load offset=-1 (i32.const 0))) ) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_address.wast:122
+let $2 = instantiate(`(module
+  (memory 1)
+  (func (export "v128.store_offset_65521")
+    (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0))
+  )
+)`);
+
+// ./test/core/simd/simd_address.wast:128
+assert_trap(() => invoke($2, `v128.store_offset_65521`, []), `out of bounds memory access`);
+
+// ./test/core/simd/simd_address.wast:130
+assert_malformed(
+  () => instantiate(`(memory 1) (func   (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0)) ) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_address.wast:143
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (v128.load offset=4294967296 (i32.const 0)))) `),
+  `i32 constant`,
+);
+
+// ./test/core/simd/simd_address.wast:151
+assert_malformed(
+  () => instantiate(`(memory 1) (func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0))) `),
+  `i32 constant`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js
new file mode 100644
index 0000000000..485ec62861
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_bit_shift.wast.js
@@ -0,0 +1,2102 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_bit_shift.wast
+
+// ./test/core/simd/simd_bit_shift.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_bit_shift.wast:44
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x80, 0xc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd]),
+    1,
+  ]),
+  [
+    i8x16([0x0, 0x80, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:47
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xa, 0xb, 0xc, 0xd]),
+    4,
+  ]),
+  [
+    i8x16([0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa0, 0xb0, 0xc0, 0xd0]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:51
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    8,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:54
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    32,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:57
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    128,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:60
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    256,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:64
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x80, 0xc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd]),
+    9,
+  ]),
+  [
+    i8x16([0x0, 0x80, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:67
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    9,
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:70
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    17,
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:73
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    33,
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:76
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    129,
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:79
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    257,
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:82
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    513,
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:85
+assert_return(
+  () => invoke($0, `i8x16.shl`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    514,
+  ]),
+  [
+    i8x16([0x0, 0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c, 0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38, 0x3c]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:90
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x80, 0xc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd]),
+    1,
+  ]),
+  [
+    i8x16([0x40, 0x60, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:93
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xa, 0xb, 0xc, 0xd]),
+    4,
+  ]),
+  [
+    i8x16([0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:97
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    8,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:100
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    32,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:103
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    128,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:106
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    256,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:110
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x80, 0xc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd]),
+    9,
+  ]),
+  [
+    i8x16([0x40, 0x60, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:113
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    9,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:116
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    17,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:119
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    33,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:122
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    129,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:125
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    257,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:128
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    513,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:131
+assert_return(
+  () => invoke($0, `i8x16.shr_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    514,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:136
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x80, 0xc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd]),
+    1,
+  ]),
+  [
+    i8x16([0xc0, 0xe0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:139
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xa, 0xb, 0xc, 0xd]),
+    4,
+  ]),
+  [
+    i8x16([0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:143
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    8,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:146
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    32,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:149
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    128,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:152
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    256,
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:156
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x80, 0xc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd]),
+    9,
+  ]),
+  [
+    i8x16([0xc0, 0xe0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:159
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    9,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:162
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    17,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:165
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    33,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:168
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    129,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:171
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    257,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:174
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    513,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:177
+assert_return(
+  () => invoke($0, `i8x16.shr_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    514,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:181
+assert_return(
+  () => invoke($0, `i8x16.shl_1`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:183
+assert_return(
+  () => invoke($0, `i8x16.shr_u_8`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:185
+assert_return(
+  () => invoke($0, `i8x16.shr_s_9`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6, 0x7, 0x7]),
+  ],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:190
+assert_return(
+  () => invoke($0, `i16x8.shl`, [
+    i16x8([0xff80, 0xffc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5]),
+    1,
+  ]),
+  [i16x8([0xff00, 0xff80, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:193
+assert_return(
+  () => invoke($0, `i16x8.shl`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    2,
+  ]),
+  [i16x8([0xc0e4, 0xc0e4, 0xc0e4, 0xc0e4, 0xc0e4, 0xc0e4, 0xc0e4, 0xc0e4])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:196
+assert_return(
+  () => invoke($0, `i16x8.shl`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    2,
+  ]),
+  [i16x8([0x48d0, 0x48d0, 0x48d0, 0x48d0, 0x48d0, 0x48d0, 0x48d0, 0x48d0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:199
+assert_return(
+  () => invoke($0, `i16x8.shl`, [
+    i16x8([0xaabb, 0xccdd, 0xeeff, 0xa0b0, 0xc0d0, 0xe0f0, 0xa0b, 0xc0d]),
+    4,
+  ]),
+  [i16x8([0xabb0, 0xcdd0, 0xeff0, 0xb00, 0xd00, 0xf00, 0xa0b0, 0xc0d0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:202
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 8]),
+  [i16x8([0x0, 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:206
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 32]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:209
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 128]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:212
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 256]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:216
+assert_return(
+  () => invoke($0, `i16x8.shl`, [
+    i16x8([0xff80, 0xffc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5]),
+    17,
+  ]),
+  [i16x8([0xff00, 0xff80, 0x0, 0x2, 0x4, 0x6, 0x8, 0xa])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:219
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 17]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:222
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 33]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:225
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 129]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:228
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 257]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:231
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 513]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:234
+assert_return(
+  () => invoke($0, `i16x8.shl`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 514]),
+  [i16x8([0x0, 0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:240
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0xff80, 0xffc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5]),
+    1,
+  ]),
+  [i16x8([0x7fc0, 0x7fe0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:243
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    2,
+  ]),
+  [i16x8([0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:246
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+    2,
+  ]),
+  [i16x8([0x242a, 0x242a, 0x242a, 0x242a, 0x242a, 0x242a, 0x242a, 0x242a])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:249
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0xaabb, 0xccdd, 0xeeff, 0xa0b0, 0xc0d0, 0xe0f0, 0xa0b, 0xc0d]),
+    4,
+  ]),
+  [i16x8([0xaab, 0xccd, 0xeef, 0xa0b, 0xc0d, 0xe0f, 0xa0, 0xc0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:252
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 8]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:256
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 32]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:259
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    128,
+  ]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:262
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    256,
+  ]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:266
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0xff80, 0xffc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5]),
+    17,
+  ]),
+  [i16x8([0x7fc0, 0x7fe0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:269
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 17]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:272
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 33]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:275
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    129,
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:278
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    257,
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:281
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    513,
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:284
+assert_return(
+  () => invoke($0, `i16x8.shr_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    514,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:290
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0xff80, 0xffc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5]),
+    1,
+  ]),
+  [i16x8([0xffc0, 0xffe0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:293
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    2,
+  ]),
+  [i16x8([0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e, 0xc0e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:296
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+    2,
+  ]),
+  [i16x8([0xe42a, 0xe42a, 0xe42a, 0xe42a, 0xe42a, 0xe42a, 0xe42a, 0xe42a])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:299
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0xaabb, 0xccdd, 0xeeff, 0xa0b0, 0xc0d0, 0xe0f0, 0xa0b, 0xc0d]),
+    4,
+  ]),
+  [i16x8([0xfaab, 0xfccd, 0xfeef, 0xfa0b, 0xfc0d, 0xfe0f, 0xa0, 0xc0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:302
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 8]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:306
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 32]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:309
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    128,
+  ]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:312
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    256,
+  ]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:316
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0xff80, 0xffc0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5]),
+    17,
+  ]),
+  [i16x8([0xffc0, 0xffe0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:319
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 17]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:322
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]), 33]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:325
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    129,
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:328
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    257,
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:331
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    513,
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:334
+assert_return(
+  () => invoke($0, `i16x8.shr_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    514,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:339
+assert_return(
+  () => invoke($0, `i16x8.shl_1`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:341
+assert_return(
+  () => invoke($0, `i16x8.shr_u_16`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:343
+assert_return(
+  () => invoke($0, `i16x8.shr_s_17`, [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:348
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x80000000, 0xffff8000, 0x0, 0xa0b0c0d]), 1]),
+  [i32x4([0x0, 0xffff0000, 0x0, 0x1416181a])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:351
+assert_return(
+  () => invoke($0, `i32x4.shl`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    2,
+  ]),
+  [i32x4([0x26580b48, 0x26580b48, 0x26580b48, 0x26580b48])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:354
+assert_return(
+  () => invoke($0, `i32x4.shl`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    2,
+  ]),
+  [i32x4([0x48d159e0, 0x48d159e0, 0x48d159e0, 0x48d159e0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:357
+assert_return(
+  () => invoke($0, `i32x4.shl`, [
+    i32x4([0xaabbccdd, 0xeeffa0b0, 0xc0d0e0f0, 0xa0b0c0d]),
+    4,
+  ]),
+  [i32x4([0xabbccdd0, 0xeffa0b00, 0xd0e0f00, 0xa0b0c0d0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:360
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 8]),
+  [i32x4([0x0, 0x100, 0xe00, 0xf00])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:364
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 32]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:367
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 128]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:370
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 256]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:374
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x80000000, 0xffff8000, 0x0, 0xa0b0c0d]), 33]),
+  [i32x4([0x0, 0xffff0000, 0x0, 0x1416181a])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:377
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 33]),
+  [i32x4([0x0, 0x2, 0x1c, 0x1e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:380
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 65]),
+  [i32x4([0x0, 0x2, 0x1c, 0x1e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:383
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 129]),
+  [i32x4([0x0, 0x2, 0x1c, 0x1e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:386
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 257]),
+  [i32x4([0x0, 0x2, 0x1c, 0x1e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:389
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 513]),
+  [i32x4([0x0, 0x2, 0x1c, 0x1e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:392
+assert_return(
+  () => invoke($0, `i32x4.shl`, [i32x4([0x0, 0x1, 0xe, 0xf]), 514]),
+  [i32x4([0x0, 0x4, 0x38, 0x3c])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:398
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x80000000, 0xffff8000, 0xc, 0xd]), 1]),
+  [i32x4([0x40000000, 0x7fffc000, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:401
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    2,
+  ]),
+  [i32x4([0x126580b4, 0x126580b4, 0x126580b4, 0x126580b4])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:404
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    2,
+  ]),
+  [i32x4([0x242af37b, 0x242af37b, 0x242af37b, 0x242af37b])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:407
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [
+    i32x4([0xaabbccdd, 0xeeffa0b0, 0xc0d0e0f0, 0xa0b0c0d]),
+    4,
+  ]),
+  [i32x4([0xaabbccd, 0xeeffa0b, 0xc0d0e0f, 0xa0b0c0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:410
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 8]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:414
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 32]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:417
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 128]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:420
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 256]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:424
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x80000000, 0xffff8000, 0xc, 0xd]), 33]),
+  [i32x4([0x40000000, 0x7fffc000, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:427
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 33]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:430
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 65]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:433
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 129]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:436
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 257]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:439
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 513]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:442
+assert_return(
+  () => invoke($0, `i32x4.shr_u`, [i32x4([0x0, 0x1, 0xe, 0xf]), 514]),
+  [i32x4([0x0, 0x0, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:448
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x80000000, 0xffff8000, 0xc, 0xd]), 1]),
+  [i32x4([0xc0000000, 0xffffc000, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:451
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    2,
+  ]),
+  [i32x4([0x126580b4, 0x126580b4, 0x126580b4, 0x126580b4])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:454
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    2,
+  ]),
+  [i32x4([0xe42af37b, 0xe42af37b, 0xe42af37b, 0xe42af37b])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:457
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [
+    i32x4([0xaabbccdd, 0xeeffa0b0, 0xc0d0e0f0, 0xa0b0c0d]),
+    4,
+  ]),
+  [i32x4([0xfaabbccd, 0xfeeffa0b, 0xfc0d0e0f, 0xa0b0c0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:461
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 8]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:464
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 32]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:467
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 128]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:470
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 256]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:474
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x80000000, 0xffff8000, 0xc, 0xd]), 33]),
+  [i32x4([0xc0000000, 0xffffc000, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:477
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 33]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:480
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 65]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:483
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 129]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:486
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 257]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:489
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 513]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:492
+assert_return(
+  () => invoke($0, `i32x4.shr_s`, [i32x4([0x0, 0x1, 0xe, 0xf]), 514]),
+  [i32x4([0x0, 0x0, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:497
+assert_return(
+  () => invoke($0, `i32x4.shl_1`, [i32x4([0x0, 0x1, 0xe, 0xf])]),
+  [i32x4([0x0, 0x2, 0x1c, 0x1e])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:499
+assert_return(
+  () => invoke($0, `i32x4.shr_u_32`, [i32x4([0x0, 0x1, 0xe, 0xf])]),
+  [i32x4([0x0, 0x1, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:501
+assert_return(
+  () => invoke($0, `i32x4.shr_s_33`, [i32x4([0x0, 0x1, 0xe, 0xf])]),
+  [i32x4([0x0, 0x0, 0x7, 0x7])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:506
+assert_return(
+  () => invoke($0, `i64x2.shl`, [i64x2([0x8000000000000000n, 0xffffffff80000000n]), 1]),
+  [i64x2([0x0n, 0xffffffff00000000n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:509
+assert_return(
+  () => invoke($0, `i64x2.shl`, [i64x2([0x112210f47de98115n, 0x112210f47de98115n]), 2]),
+  [i64x2([0x448843d1f7a60454n, 0x448843d1f7a60454n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:512
+assert_return(
+  () => invoke($0, `i64x2.shl`, [i64x2([0x1234567890abcdefn, 0x1234567890abcdefn]), 2]),
+  [i64x2([0x48d159e242af37bcn, 0x48d159e242af37bcn])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:515
+assert_return(
+  () => invoke($0, `i64x2.shl`, [i64x2([0xaabbccddeeffa0b0n, 0xc0d0e0f00a0b0c0dn]), 4]),
+  [i64x2([0xabbccddeeffa0b00n, 0xd0e0f00a0b0c0d0n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:518
+assert_return(
+  () => invoke($0, `i64x2.shl`, [i64x2([0xaabbccddeeffa0b0n, 0xc0d0e0f00a0b0c0dn]), 8]),
+  [i64x2([0xbbccddeeffa0b000n, 0xd0e0f00a0b0c0d00n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:521
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 16]), [i64x2([0x10000n, 0xf0000n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:524
+assert_return(
+  () => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 32]),
+  [i64x2([0x100000000n, 0xf00000000n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:528
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 128]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:531
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 256]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:535
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 65]), [i64x2([0x2n, 0x1en])]);
+
+// ./test/core/simd/simd_bit_shift.wast:538
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 129]), [i64x2([0x2n, 0x1en])]);
+
+// ./test/core/simd/simd_bit_shift.wast:541
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 257]), [i64x2([0x2n, 0x1en])]);
+
+// ./test/core/simd/simd_bit_shift.wast:544
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 513]), [i64x2([0x2n, 0x1en])]);
+
+// ./test/core/simd/simd_bit_shift.wast:547
+assert_return(() => invoke($0, `i64x2.shl`, [i64x2([0x1n, 0xfn]), 514]), [i64x2([0x4n, 0x3cn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:553
+assert_return(
+  () => invoke($0, `i64x2.shr_u`, [
+    i64x2([0x8000000000000000n, 0xffffffff80000000n]),
+    1,
+  ]),
+  [i64x2([0x4000000000000000n, 0x7fffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:556
+assert_return(
+  () => invoke($0, `i64x2.shr_u`, [
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+    2,
+  ]),
+  [i64x2([0x448843d1f7a6045n, 0x448843d1f7a6045n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:559
+assert_return(
+  () => invoke($0, `i64x2.shr_u`, [
+    i64x2([0x90abcdef87654321n, 0x90abcdef87654321n]),
+    2,
+  ]),
+  [i64x2([0x242af37be1d950c8n, 0x242af37be1d950c8n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:562
+assert_return(
+  () => invoke($0, `i64x2.shr_u`, [
+    i64x2([0xaabbccddeeffa0b0n, 0xc0d0e0f00a0b0c0dn]),
+    4,
+  ]),
+  [i64x2([0xaabbccddeeffa0bn, 0xc0d0e0f00a0b0c0n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:565
+assert_return(
+  () => invoke($0, `i64x2.shr_u`, [
+    i64x2([0xaabbccddeeffa0b0n, 0xc0d0e0f00a0b0c0dn]),
+    8,
+  ]),
+  [i64x2([0xaabbccddeeffa0n, 0xc0d0e0f00a0b0cn])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:568
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 16]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:571
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 32]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:575
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 128]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:578
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 256]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:582
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 65]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:585
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 129]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:588
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 257]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:591
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x1n, 0xfn]), 513]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:594
+assert_return(() => invoke($0, `i64x2.shr_u`, [i64x2([0x0n, 0xfn]), 514]), [i64x2([0x0n, 0x3n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:600
+assert_return(
+  () => invoke($0, `i64x2.shr_s`, [
+    i64x2([0x8000000000000000n, 0xffffffff80000000n]),
+    1,
+  ]),
+  [i64x2([0xc000000000000000n, 0xffffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:603
+assert_return(
+  () => invoke($0, `i64x2.shr_s`, [
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+    2,
+  ]),
+  [i64x2([0x448843d1f7a6045n, 0x448843d1f7a6045n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:606
+assert_return(
+  () => invoke($0, `i64x2.shr_s`, [
+    i64x2([0x90abcdef87654321n, 0x90abcdef87654321n]),
+    2,
+  ]),
+  [i64x2([0xe42af37be1d950c8n, 0xe42af37be1d950c8n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:609
+assert_return(
+  () => invoke($0, `i64x2.shr_s`, [
+    i64x2([0xaabbccddeeffa0b0n, 0xc0d0e0f00a0b0c0dn]),
+    4,
+  ]),
+  [i64x2([0xfaabbccddeeffa0bn, 0xfc0d0e0f00a0b0c0n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:612
+assert_return(
+  () => invoke($0, `i64x2.shr_s`, [
+    i64x2([0xffaabbccddeeffa0n, 0xc0d0e0f00a0b0c0dn]),
+    8,
+  ]),
+  [i64x2([0xffffaabbccddeeffn, 0xffc0d0e0f00a0b0cn])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:615
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 16]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:618
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 32]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:622
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 128]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:625
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 256]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:629
+assert_return(
+  () => invoke($0, `i64x2.shr_s`, [
+    i64x2([0x8000000000000000n, 0xffffffff80000000n]),
+    65,
+  ]),
+  [i64x2([0xc000000000000000n, 0xffffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_bit_shift.wast:632
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0xcn, 0xdn]), 65]), [i64x2([0x6n, 0x6n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:635
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 129]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:638
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 257]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:641
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 513]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:644
+assert_return(() => invoke($0, `i64x2.shr_s`, [i64x2([0x1n, 0xfn]), 514]), [i64x2([0x0n, 0x3n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:649
+assert_return(() => invoke($0, `i64x2.shl_1`, [i64x2([0x1n, 0xfn])]), [i64x2([0x2n, 0x1en])]);
+
+// ./test/core/simd/simd_bit_shift.wast:651
+assert_return(() => invoke($0, `i64x2.shr_u_64`, [i64x2([0x1n, 0xfn])]), [i64x2([0x1n, 0xfn])]);
+
+// ./test/core/simd/simd_bit_shift.wast:653
+assert_return(() => invoke($0, `i64x2.shr_s_65`, [i64x2([0x1n, 0xfn])]), [i64x2([0x0n, 0x7n])]);
+
+// ./test/core/simd/simd_bit_shift.wast:658
+let $1 = instantiate(`(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)
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_bit_shift.wast:949
+assert_return(() => invoke($1, `i8x16.shl-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:950
+assert_return(() => invoke($1, `i8x16.shr_s-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:951
+assert_return(() => invoke($1, `i8x16.shr_u-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:952
+assert_return(() => invoke($1, `i16x8.shl-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:953
+assert_return(() => invoke($1, `i16x8.shr_s-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:954
+assert_return(() => invoke($1, `i16x8.shr_u-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:955
+assert_return(() => invoke($1, `i32x4.shl-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:956
+assert_return(() => invoke($1, `i32x4.shr_s-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:957
+assert_return(() => invoke($1, `i32x4.shr_u-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:958
+assert_return(() => invoke($1, `i64x2.shl-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:959
+assert_return(() => invoke($1, `i64x2.shr_s-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:960
+assert_return(() => invoke($1, `i64x2.shr_u-in-block`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:961
+assert_return(() => invoke($1, `nested-i8x16.shl`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:962
+assert_return(() => invoke($1, `nested-i8x16.shr_s`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:963
+assert_return(() => invoke($1, `nested-i8x16.shr_u`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:964
+assert_return(() => invoke($1, `nested-i16x8.shl`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:965
+assert_return(() => invoke($1, `nested-i16x8.shr_s`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:966
+assert_return(() => invoke($1, `nested-i16x8.shr_u`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:967
+assert_return(() => invoke($1, `nested-i32x4.shl`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:968
+assert_return(() => invoke($1, `nested-i32x4.shr_s`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:969
+assert_return(() => invoke($1, `nested-i32x4.shr_u`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:970
+assert_return(() => invoke($1, `nested-i64x2.shl`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:971
+assert_return(() => invoke($1, `nested-i64x2.shr_s`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:972
+assert_return(() => invoke($1, `nested-i64x2.shr_u`, []), []);
+
+// ./test/core/simd/simd_bit_shift.wast:976
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.shl   (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:977
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.shr_s (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:978
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.shr_u (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:979
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.shl   (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:980
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.shr_s (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:981
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.shr_u (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:982
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.shl   (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:983
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.shr_s (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:984
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.shr_u (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:985
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.shl   (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:986
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.shr_s (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:987
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.shr_u (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:991
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.shl_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:992
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.shl_r (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:993
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.shr   (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:994
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.shl_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:995
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.shl_r (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:996
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.shr   (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:997
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.shl_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:998
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.shl_r (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:999
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.shr   (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1000
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.shl_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1001
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.shl_r (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1002
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.shr   (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1003
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.shl   (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1004
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1005
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1009
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.shl-1st-arg-empty (result v128)
+      (i8x16.shl (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1017
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1025
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.shl-arg-empty (result v128)
+      (i8x16.shl)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1033
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.shr_u-1st-arg-empty (result v128)
+      (i16x8.shr_u (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1041
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1049
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.shr_u-arg-empty (result v128)
+      (i16x8.shr_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1057
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.shr_s-1st-arg-empty (result v128)
+      (i32x4.shr_s (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1065
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.shr_s-last-arg-empty (result v128)
+      (i32x4.shr_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1073
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.shr_s-arg-empty (result v128)
+      (i32x4.shr_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1081
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.shl-1st-arg-empty (result v128)
+      (i64x2.shl (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1089
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.shr_u-last-arg-empty (result v128)
+      (i64x2.shr_u (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bit_shift.wast:1097
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.shr_s-arg-empty (result v128)
+      (i64x2.shr_s)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js
new file mode 100644
index 0000000000..0c270c4cc7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_bitwise.wast.js
@@ -0,0 +1,2769 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_bitwise.wast
+
+// ./test/core/simd/simd_bitwise.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_bitwise.wast:15
+assert_return(
+  () => invoke($0, `not`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:17
+assert_return(
+  () => invoke($0, `not`, [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:19
+assert_return(
+  () => invoke($0, `not`, [i32x4([0xffffffff, 0x0, 0xffffffff, 0x0])]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:21
+assert_return(
+  () => invoke($0, `not`, [i32x4([0x0, 0xffffffff, 0x0, 0xffffffff])]),
+  [i32x4([0xffffffff, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:23
+assert_return(
+  () => invoke($0, `not`, [i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555])]),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:25
+assert_return(
+  () => invoke($0, `not`, [i32x4([0xcccccccc, 0xcccccccc, 0xcccccccc, 0xcccccccc])]),
+  [i32x4([0x33333333, 0x33333333, 0x33333333, 0x33333333])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:27
+assert_return(
+  () => invoke($0, `not`, [i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2])]),
+  [i32x4([0xb669fd2d, 0xb669fd2d, 0xb669fd2d, 0xb669fd2d])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:29
+assert_return(
+  () => invoke($0, `not`, [i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678])]),
+  [i32x4([0xedcba987, 0xedcba987, 0xedcba987, 0xedcba987])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:31
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:34
+assert_return(
+  () => invoke($0, `and`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:37
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:40
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:43
+assert_return(
+  () => invoke($0, `and`, [i32x4([0x1, 0x1, 0x1, 0x1]), i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:46
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i32x4([0x55, 0x55, 0x55, 0x55])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:49
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:52
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xa, 0x80, 0x5, 0xa5]),
+  ]),
+  [i32x4([0xa, 0x80, 0x0, 0xa0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:55
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+  ]),
+  [i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:58
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:61
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:64
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i32x4([0x5555, 0xffff, 0x55ff, 0x5fff]),
+  ]),
+  [i32x4([0x5555, 0x5555, 0x5555, 0x5555])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:67
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:70
+assert_return(
+  () => invoke($0, `and`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0x10204468, 0x10204468, 0x10204468, 0x10204468])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:73
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:76
+assert_return(
+  () => invoke($0, `or`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:79
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:82
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:85
+assert_return(
+  () => invoke($0, `or`, [i32x4([0x1, 0x1, 0x1, 0x1]), i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:88
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i32x4([0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:91
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:94
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xa, 0x80, 0x5, 0xa5]),
+  ]),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaf, 0xaaaaaaaf])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:97
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:100
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:103
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:106
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i32x4([0x5555, 0xffff, 0x55ff, 0x5fff]),
+  ]),
+  [i32x4([0x55555555, 0x5555ffff, 0x555555ff, 0x55555fff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:109
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:112
+assert_return(
+  () => invoke($0, `or`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0x92bfdfff, 0x92bfdfff, 0x92bfdfff, 0x92bfdfff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:115
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:118
+assert_return(
+  () => invoke($0, `xor`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:121
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:124
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:127
+assert_return(
+  () => invoke($0, `xor`, [i32x4([0x1, 0x1, 0x1, 0x1]), i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:130
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i32x4([0xaa, 0xaa, 0xaa, 0xaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:133
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:136
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xa, 0x80, 0x5, 0xa5]),
+  ]),
+  [i32x4([0xaaaaaaa0, 0xaaaaaa2a, 0xaaaaaaaf, 0xaaaaaa0f])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:139
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+  ]),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:142
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:145
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:148
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i32x4([0x5555, 0xffff, 0x55ff, 0x5fff]),
+  ]),
+  [i32x4([0x55550000, 0x5555aaaa, 0x555500aa, 0x55550aaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:151
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:154
+assert_return(
+  () => invoke($0, `xor`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0x829f9b97, 0x829f9b97, 0x829f9b97, 0x829f9b97])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:157
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb]),
+    i32x4([0x112345, 0xf00fffff, 0x10112021, 0xbbaabbaa]),
+  ]),
+  [i32x4([0xbbaababa, 0xabbaaaaa, 0xabaabbba, 0xaabbaabb])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:161
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:165
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb]),
+    i32x4([0x11111111, 0x11111111, 0x11111111, 0x11111111]),
+  ]),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:169
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb, 0xbbbbbbbb]),
+    i32x4([0x1234567, 0x89abcdef, 0xfedcba98, 0x76543210]),
+  ]),
+  [i32x4([0xbabababa, 0xbabababa, 0xabababab, 0xabababab])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:173
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i32x4([0x1234567, 0x89abcdef, 0xfedcba98, 0x76543210]),
+  ]),
+  [i32x4([0x54761032, 0xdcfe98ba, 0xab89efcd, 0x23016745])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:177
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i32x4([0x55555555, 0xaaaaaaaa, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x55555555, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:181
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    i32x4([0xb669fd2e, 0xb669fd2e, 0xb669fd2e, 0xb669fd2e]),
+    i32x4([0xcdefcdef, 0xcdefcdef, 0xcdefcdef, 0xcdefcdef]),
+  ]),
+  [i32x4([0x7b8630c2, 0x7b8630c2, 0x7b8630c2, 0x7b8630c2])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:185
+assert_return(
+  () => invoke($0, `bitselect`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0xcdefcdef, 0xcdefcdef, 0xcdefcdef, 0xcdefcdef]),
+  ]),
+  [i32x4([0x10244468, 0x10244468, 0x10244468, 0x10244468])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:189
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:192
+assert_return(
+  () => invoke($0, `andnot`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:195
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:198
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:201
+assert_return(
+  () => invoke($0, `andnot`, [i32x4([0x1, 0x1, 0x1, 0x1]), i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:204
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i32x4([0xaa, 0xaa, 0xaa, 0xaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:207
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0xff, 0xff, 0xff, 0xff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:210
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i32x4([0xa, 0x80, 0x5, 0xa5]),
+  ]),
+  [i32x4([0xaaaaaaa0, 0xaaaaaa2a, 0xaaaaaaaa, 0xaaaaaa0a])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:213
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+  ]),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:216
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:219
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:222
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i32x4([0x5555, 0xffff, 0x55ff, 0x5fff]),
+  ]),
+  [i32x4([0x55550000, 0x55550000, 0x55550000, 0x55550000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:225
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:228
+assert_return(
+  () => invoke($0, `andnot`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0x2141210, 0x2141210, 0x2141210, 0x2141210])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:233
+assert_return(
+  () => invoke($0, `not`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000000000587747),
+      value("f32", 0.00000000000000000000000000000000000000587747),
+      value("f32", 0.00000000000000000000000000000000000000587747),
+      value("f32", 0.00000000000000000000000000000000000000587747),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:235
+assert_return(
+  () => invoke($0, `not`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000000000000000000000000000000000000587747),
+      value("f32", -0.00000000000000000000000000000000000000587747),
+      value("f32", -0.00000000000000000000000000000000000000587747),
+      value("f32", -0.00000000000000000000000000000000000000587747),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:237
+assert_return(
+  () => invoke($0, `not`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [i32x4([0x7fffff, 0x7fffff, 0x7fffff, 0x7fffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:239
+assert_return(
+  () => invoke($0, `not`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [i32x4([0x807fffff, 0x807fffff, 0x807fffff, 0x807fffff])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:241
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:244
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:247
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:250
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:253
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:256
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:259
+assert_return(
+  () => invoke($0, `and`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:262
+assert_return(
+  () => invoke($0, `and`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:265
+assert_return(
+  () => invoke($0, `and`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:268
+assert_return(
+  () => invoke($0, `and`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:271
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:274
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:277
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:280
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:283
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:286
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:289
+assert_return(
+  () => invoke($0, `or`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:292
+assert_return(
+  () => invoke($0, `or`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:295
+assert_return(
+  () => invoke($0, `or`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:298
+assert_return(
+  () => invoke($0, `or`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:301
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:304
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:307
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x400000, 0x400000, 0x400000, 0x400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:310
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x80400000, 0x80400000, 0x80400000, 0x80400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:313
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:316
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x80400000, 0x80400000, 0x80400000, 0x80400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:319
+assert_return(
+  () => invoke($0, `xor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x400000, 0x400000, 0x400000, 0x400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:322
+assert_return(
+  () => invoke($0, `xor`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:325
+assert_return(
+  () => invoke($0, `xor`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:328
+assert_return(
+  () => invoke($0, `xor`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:331
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [i32x4([0xffc00000, 0xffc00000, 0xffc00000, 0xffc00000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:335
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:339
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:343
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:347
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:351
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:355
+assert_return(
+  () => invoke($0, `bitselect`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:359
+assert_return(
+  () => invoke($0, `bitselect`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:363
+assert_return(
+  () => invoke($0, `bitselect`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:367
+assert_return(
+  () => invoke($0, `bitselect`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([2779096600, 2779096600, 2779096600, 2779096600]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:371
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:374
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:377
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x400000, 0x400000, 0x400000, 0x400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:380
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x80400000, 0x80400000, 0x80400000, 0x80400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:383
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:386
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x400000, 0x400000, 0x400000, 0x400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:389
+assert_return(
+  () => invoke($0, `andnot`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x400000, 0x400000, 0x400000, 0x400000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:392
+assert_return(
+  () => invoke($0, `andnot`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_bitwise.wast:395
+assert_return(
+  () => invoke($0, `andnot`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:398
+assert_return(
+  () => invoke($0, `andnot`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_bitwise.wast:405
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.not (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:407
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.and (i32.const 0) (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:408
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.and (v128.const i32x4 0 0 0 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:409
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.and (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:411
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.or (i32.const 0) (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:412
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.or (v128.const i32x4 0 0 0 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:413
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.or (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:415
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.xor (i32.const 0) (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:416
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.xor (v128.const i32x4 0 0 0 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:417
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.xor (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:419
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:420
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:421
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.bitselect (i32.const 0) (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:423
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.andnot (i32.const 0) (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:424
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.andnot (v128.const i32x4 0 0 0 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:425
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (v128.andnot (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:429
+let $1 = instantiate(`(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))
+          )
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_bitwise.wast:700
+assert_return(() => invoke($1, `v128.not-in-block`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:701
+assert_return(() => invoke($1, `v128.and-in-block`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:702
+assert_return(() => invoke($1, `v128.or-in-block`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:703
+assert_return(() => invoke($1, `v128.xor-in-block`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:704
+assert_return(() => invoke($1, `v128.bitselect-in-block`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:705
+assert_return(() => invoke($1, `v128.andnot-in-block`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:706
+assert_return(() => invoke($1, `nested-v128.not`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:707
+assert_return(() => invoke($1, `nested-v128.and`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:708
+assert_return(() => invoke($1, `nested-v128.or`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:709
+assert_return(() => invoke($1, `nested-v128.xor`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:710
+assert_return(() => invoke($1, `nested-v128.bitselect`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:711
+assert_return(() => invoke($1, `nested-v128.andnot`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:712
+assert_return(() => invoke($1, `as-param`, []), []);
+
+// ./test/core/simd/simd_bitwise.wast:717
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.not-arg-empty (result v128)
+      (v128.not)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:725
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.and-1st-arg-empty (result v128)
+      (v128.and (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:733
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.and-arg-empty (result v128)
+      (v128.and)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:741
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.or-1st-arg-empty (result v128)
+      (v128.or (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:749
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.or-arg-empty (result v128)
+      (v128.or)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:757
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.xor-1st-arg-empty (result v128)
+      (v128.xor (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:765
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.xor-arg-empty (result v128)
+      (v128.xor)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:773
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.andnot-1st-arg-empty (result v128)
+      (v128.andnot (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:781
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.andnot-arg-empty (result v128)
+      (v128.andnot)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:789
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:797
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.bitselect-two-args-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_bitwise.wast:805
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.bitselect-arg-empty (result v128)
+      (v128.bitselect)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js
new file mode 100644
index 0000000000..63959fad79
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_boolean.wast.js
@@ -0,0 +1,2455 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_boolean.wast
+
+// ./test/core/simd/simd_boolean.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_boolean.wast:21
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:23
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:25
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:27
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:29
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0xff, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xf]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:31
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:33
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:35
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:37
+assert_return(
+  () => invoke($0, `i8x16.any_true`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:39
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:41
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:43
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:45
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:47
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0xff, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xf]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:49
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:51
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:53
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:55
+assert_return(
+  () => invoke($0, `i8x16.all_true`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:57
+assert_return(
+  () => invoke($0, `i8x16.bitmask`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 65535)],
+);
+
+// ./test/core/simd/simd_boolean.wast:59
+assert_return(
+  () => invoke($0, `i8x16.bitmask`, [
+    i8x16([0xff, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xf]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:63
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:65
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:67
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:69
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:71
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [
+    i16x8([0xffff, 0x0, 0x1, 0x2, 0xb, 0xc, 0xd, 0xf]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:73
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:75
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:77
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [
+    i16x8([0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:79
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:81
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:83
+assert_return(
+  () => invoke($0, `i16x8.any_true`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:85
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:87
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:89
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:91
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:93
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [
+    i16x8([0xffff, 0x0, 0x1, 0x2, 0xb, 0xc, 0xd, 0xf]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:95
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:97
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:99
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [
+    i16x8([0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:101
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:103
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:105
+assert_return(
+  () => invoke($0, `i16x8.all_true`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:107
+assert_return(
+  () => invoke($0, `i16x8.bitmask`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 255)],
+);
+
+// ./test/core/simd/simd_boolean.wast:109
+assert_return(
+  () => invoke($0, `i16x8.bitmask`, [
+    i16x8([0xffff, 0x0, 0x1, 0x2, 0xb, 0xc, 0xd, 0xf]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:113
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0x0, 0x0, 0x0, 0x0])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:115
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0x0, 0x0, 0x1, 0x0])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:117
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0x1, 0x1, 0x0, 0x1])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:119
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0x1, 0x1, 0x1, 0x1])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:121
+assert_return(
+  () => invoke($0, `i32x4.any_true`, [i32x4([0xffffffff, 0x0, 0x1, 0xf])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:123
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0x0, 0x0, 0x0, 0x0])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:125
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0xff, 0xff, 0xff, 0xff])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:127
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0xab, 0xab, 0xab, 0xab])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:129
+assert_return(() => invoke($0, `i32x4.any_true`, [i32x4([0x55, 0x55, 0x55, 0x55])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:131
+assert_return(
+  () => invoke($0, `i32x4.any_true`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:133
+assert_return(
+  () => invoke($0, `i32x4.any_true`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:135
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0x0, 0x0, 0x0, 0x0])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:137
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0x0, 0x0, 0x1, 0x0])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:139
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0x1, 0x1, 0x0, 0x1])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:141
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0x1, 0x1, 0x1, 0x1])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:143
+assert_return(
+  () => invoke($0, `i32x4.all_true`, [i32x4([0xffffffff, 0x0, 0x1, 0xf])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:145
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0x0, 0x0, 0x0, 0x0])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:147
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0xff, 0xff, 0xff, 0xff])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:149
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0xab, 0xab, 0xab, 0xab])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:151
+assert_return(() => invoke($0, `i32x4.all_true`, [i32x4([0x55, 0x55, 0x55, 0x55])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:153
+assert_return(
+  () => invoke($0, `i32x4.all_true`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:155
+assert_return(
+  () => invoke($0, `i32x4.all_true`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:157
+assert_return(
+  () => invoke($0, `i32x4.bitmask`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 15)],
+);
+
+// ./test/core/simd/simd_boolean.wast:159
+assert_return(
+  () => invoke($0, `i32x4.bitmask`, [i32x4([0xffffffff, 0x0, 0x1, 0xf])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:163
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0x0n, 0x0n])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:165
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0x0n, 0x1n])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:167
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0x1n, 0x0n])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:169
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0x1n, 0x1n])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:171
+assert_return(
+  () => invoke($0, `i64x2.all_true`, [i64x2([0xffffffffffffffffn, 0x0n])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:173
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0x0n, 0x0n])]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_boolean.wast:175
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0xffn, 0xffn])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:177
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0xabn, 0xabn])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:179
+assert_return(() => invoke($0, `i64x2.all_true`, [i64x2([0x55n, 0x55n])]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_boolean.wast:181
+assert_return(
+  () => invoke($0, `i64x2.bitmask`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [value("i32", 3)],
+);
+
+// ./test/core/simd/simd_boolean.wast:183
+assert_return(
+  () => invoke($0, `i64x2.bitmask`, [i64x2([0xffffffffffffffffn, 0xfn])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:188
+let $1 = instantiate(`(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)))
+    )
+)`);
+
+// ./test/core/simd/simd_boolean.wast:472
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_if_cond`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:474
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_if_cond`, [
+    i8x16([0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:476
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_if_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:479
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_if_cond`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:481
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_if_cond`, [
+    i16x8([0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:483
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_if_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:486
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_if_cond`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:488
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_if_cond`, [i32x4([0x0, 0x0, 0x1, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:490
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_if_cond`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:495
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_if_cond`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:497
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_if_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:499
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_if_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:502
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_if_cond`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:504
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_if_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:506
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_if_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:509
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_if_cond`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:511
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_if_cond`, [i32x4([0x1, 0x1, 0x1, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:513
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_if_cond`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:517
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_select_cond`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:519
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_select_cond`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:521
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_select_cond`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:523
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_select_cond`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:525
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_select_cond`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:527
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_select_cond`, [i32x4([0x0, 0x0, 0x1, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:530
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_select_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:532
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_select_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:534
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_select_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:536
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_select_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:538
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_select_cond`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:540
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_select_cond`, [i32x4([0x1, 0x1, 0x0, 0x1])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:543
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_br_if_cond`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:545
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_br_if_cond`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:547
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_br_if_cond`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:549
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_br_if_cond`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:551
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_br_if_cond`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:553
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_br_if_cond`, [i32x4([0x0, 0x0, 0x1, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:556
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_br_if_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:558
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_br_if_cond`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:560
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_br_if_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:562
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_br_if_cond`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:564
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_br_if_cond`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:566
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_br_if_cond`, [i32x4([0x1, 0x1, 0x0, 0x1])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:569
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.and_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:572
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.and_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:575
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.and_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:578
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.and_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:581
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.and_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:584
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.and_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:587
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.and_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:590
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.and_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:593
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.and_operand`, [
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:597
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.or_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:600
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.or_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:603
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.or_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:606
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.or_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:609
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.or_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:612
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.or_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:615
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.or_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:618
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.or_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:621
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.or_operand`, [
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:625
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.xor_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:628
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.xor_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:631
+assert_return(
+  () => invoke($1, `i8x16_any_true_as_i32.xor_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:634
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.xor_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:637
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.xor_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:640
+assert_return(
+  () => invoke($1, `i16x8_any_true_as_i32.xor_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:643
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.xor_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:646
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.xor_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:649
+assert_return(
+  () => invoke($1, `i32x4_any_true_as_i32.xor_operand`, [
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:653
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.and_operand`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:656
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.and_operand`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:659
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.and_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:662
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.and_operand`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:665
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.and_operand`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:668
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.and_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:671
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.and_operand`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:674
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.and_operand`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:677
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.and_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x1, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:681
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.or_operand`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:684
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.or_operand`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:687
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.or_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:690
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.or_operand`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:693
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.or_operand`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:696
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.or_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:699
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.or_operand`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:702
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.or_operand`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:705
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.or_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:709
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.xor_operand`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:712
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.xor_operand`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:715
+assert_return(
+  () => invoke($1, `i8x16_all_true_as_i32.xor_operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:718
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.xor_operand`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:721
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.xor_operand`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:724
+assert_return(
+  () => invoke($1, `i16x8_all_true_as_i32.xor_operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:727
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.xor_operand`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:730
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.xor_operand`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x0, 0x1]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:733
+assert_return(
+  () => invoke($1, `i32x4_all_true_as_i32.xor_operand`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:737
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.not`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:739
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.not`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:741
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.not`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:743
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.not`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:745
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.not`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:747
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.not`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:749
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.not`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:751
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.not`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:753
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.not`, [i32x4([0x0, 0x0, 0xffffffff, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:756
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.and`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:759
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.and`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:762
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.and`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:765
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.and`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:768
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.and`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:771
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.and`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:774
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.and`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:777
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.and`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:780
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.and`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:784
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.or`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:787
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.or`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:790
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.or`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:793
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.or`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:796
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.or`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:799
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.or`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:802
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.or`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:805
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.or`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:808
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.or`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:812
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.xor`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:815
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.xor`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:818
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.xor`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:821
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.xor`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:824
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.xor`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:827
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.xor`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:830
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.xor`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:833
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.xor`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:836
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.xor`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:840
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.bitselect`, [
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:844
+assert_return(
+  () => invoke($1, `i8x16_any_true_with_v128.bitselect`, [
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:848
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.bitselect`, [
+    i16x8([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:852
+assert_return(
+  () => invoke($1, `i16x8_any_true_with_v128.bitselect`, [
+    i16x8([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xff, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:856
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.bitselect`, [
+    i32x4([0xaa, 0xaa, 0xaa, 0xaa]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:860
+assert_return(
+  () => invoke($1, `i32x4_any_true_with_v128.bitselect`, [
+    i32x4([0xaa, 0xaa, 0xaa, 0xaa]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+    i32x4([0x55, 0x55, 0xff, 0x55]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:865
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.not`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:867
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.not`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:869
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.not`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:871
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.not`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:873
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.not`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:875
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.not`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:877
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.not`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:879
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.not`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:881
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.not`, [i32x4([0x0, 0x0, 0xffffffff, 0x0])]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:884
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.and`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:887
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.and`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:890
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.and`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:893
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.and`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:896
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.and`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:899
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.and`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:902
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.and`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:905
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.and`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:908
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.and`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:912
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.or`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:915
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.or`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:918
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.or`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:921
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.or`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:924
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.or`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:927
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.or`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:930
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.or`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:933
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.or`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:936
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.or`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+    i32x4([0x0, 0x0, 0xffffffff, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:940
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.xor`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:943
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.xor`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:946
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.xor`, [
+    i8x16([0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff]),
+    i8x16([0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:949
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.xor`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:952
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.xor`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:955
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.xor`, [
+    i16x8([0x0, 0xffff, 0x0, 0xffff, 0x0, 0xffff, 0x0, 0xffff]),
+    i16x8([0xffff, 0x0, 0xffff, 0x0, 0xffff, 0x0, 0xffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:958
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.xor`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:961
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.xor`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:964
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.xor`, [
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0xffffffff, 0x0, 0xffffffff, 0x0]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:968
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.bitselect`, [
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:972
+assert_return(
+  () => invoke($1, `i8x16_all_true_with_v128.bitselect`, [
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:976
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.bitselect`, [
+    i16x8([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:980
+assert_return(
+  () => invoke($1, `i16x8_all_true_with_v128.bitselect`, [
+    i16x8([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+    i16x8([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:984
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.bitselect`, [
+    i32x4([0xaa, 0xaa, 0xaa, 0xaa]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_boolean.wast:988
+assert_return(
+  () => invoke($1, `i32x4_all_true_with_v128.bitselect`, [
+    i32x4([0xaa, 0xaa, 0xaa, 0xaa]),
+    i32x4([0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_boolean.wast:995
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (v128.any_true (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:996
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i8x16.all_true (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:997
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (v128.any_true (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:998
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i16x8.all_true (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:999
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (v128.any_true (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1000
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32x4.all_true (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1004
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1005
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1006
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1007
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1011
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1019
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.all_true-arg-empty (result v128)
+      (i8x16.all_true)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1027
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1035
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.all_true-arg-empty (result v128)
+      (i16x8.all_true)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1043
+assert_invalid(
+  () => instantiate(`(module
+    (func $$v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_boolean.wast:1051
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.all_true-arg-empty (result v128)
+      (i32x4.all_true)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js
new file mode 100644
index 0000000000..76c05b43bc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_const.wast.js
@@ -0,0 +1,4681 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_const.wast
+
+// ./test/core/simd/simd_const.wast:3
+let $0 = instantiate(`(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF) drop))`);
+
+// ./test/core/simd/simd_const.wast:4
+let $1 = instantiate(`(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))`);
+
+// ./test/core/simd/simd_const.wast:5
+let $2 = instantiate(`(module (func (v128.const i8x16  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255) drop))`);
+
+// ./test/core/simd/simd_const.wast:6
+let $3 = instantiate(`(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop))`);
+
+// ./test/core/simd/simd_const.wast:7
+let $4 = instantiate(`(module (func (v128.const i16x8  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF) drop))`);
+
+// ./test/core/simd/simd_const.wast:8
+let $5 = instantiate(`(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop))`);
+
+// ./test/core/simd/simd_const.wast:9
+let $6 = instantiate(`(module (func (v128.const i16x8  65535  65535  65535  65535  65535  65535  65535  65535) drop))`);
+
+// ./test/core/simd/simd_const.wast:10
+let $7 = instantiate(`(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop))`);
+
+// ./test/core/simd/simd_const.wast:11
+let $8 = instantiate(`(module (func (v128.const i16x8  65_535  65_535  65_535  65_535  65_535  65_535  65_535  65_535) drop))`);
+
+// ./test/core/simd/simd_const.wast:12
+let $9 = instantiate(`(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop))`);
+
+// ./test/core/simd/simd_const.wast:13
+let $10 = instantiate(`(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))`);
+
+// ./test/core/simd/simd_const.wast:14
+let $11 = instantiate(`(module (func (v128.const i16x8  0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop))`);
+
+// ./test/core/simd/simd_const.wast:15
+let $12 = instantiate(`(module (func (v128.const i32x4  0xffffffff  0xffffffff  0xffffffff  0xffffffff) drop))`);
+
+// ./test/core/simd/simd_const.wast:16
+let $13 = instantiate(`(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop))`);
+
+// ./test/core/simd/simd_const.wast:17
+let $14 = instantiate(`(module (func (v128.const i32x4  4294967295  4294967295  4294967295  4294967295) drop))`);
+
+// ./test/core/simd/simd_const.wast:18
+let $15 = instantiate(`(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop))`);
+
+// ./test/core/simd/simd_const.wast:19
+let $16 = instantiate(`(module (func (v128.const i32x4  0xffff_ffff  0xffff_ffff  0xffff_ffff  0xffff_ffff) drop))`);
+
+// ./test/core/simd/simd_const.wast:20
+let $17 = instantiate(`(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop))`);
+
+// ./test/core/simd/simd_const.wast:21
+let $18 = instantiate(`(module (func (v128.const i32x4 4_294_967_295  4_294_967_295  4_294_967_295  4_294_967_295) drop))`);
+
+// ./test/core/simd/simd_const.wast:22
+let $19 = instantiate(`(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop))`);
+
+// ./test/core/simd/simd_const.wast:23
+let $20 = instantiate(`(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop))`);
+
+// ./test/core/simd/simd_const.wast:24
+let $21 = instantiate(`(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop))`);
+
+// ./test/core/simd/simd_const.wast:25
+let $22 = instantiate(`(module (func (v128.const i64x2  0xffffffffffffffff  0xffffffffffffffff) drop))`);
+
+// ./test/core/simd/simd_const.wast:26
+let $23 = instantiate(`(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop))`);
+
+// ./test/core/simd/simd_const.wast:27
+let $24 = instantiate(`(module (func (v128.const i64x2  18446744073709551615 18446744073709551615) drop))`);
+
+// ./test/core/simd/simd_const.wast:28
+let $25 = instantiate(`(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop))`);
+
+// ./test/core/simd/simd_const.wast:29
+let $26 = instantiate(`(module (func (v128.const i64x2  0xffff_ffff_ffff_ffff  0xffff_ffff_ffff_ffff) drop))`);
+
+// ./test/core/simd/simd_const.wast:30
+let $27 = instantiate(`(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop))`);
+
+// ./test/core/simd/simd_const.wast:31
+let $28 = instantiate(`(module (func (v128.const i64x2  18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop))`);
+
+// ./test/core/simd/simd_const.wast:32
+let $29 = instantiate(`(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop))`);
+
+// ./test/core/simd/simd_const.wast:33
+let $30 = instantiate(`(module (func (v128.const i64x2  0_123_456_789 0_123_456_789) drop))`);
+
+// ./test/core/simd/simd_const.wast:34
+let $31 = instantiate(`(module (func (v128.const i64x2  0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop))`);
+
+// ./test/core/simd/simd_const.wast:35
+let $32 = instantiate(`(module (func (v128.const f32x4  0x1p127  0x1p127  0x1p127  0x1p127) drop))`);
+
+// ./test/core/simd/simd_const.wast:36
+let $33 = instantiate(`(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop))`);
+
+// ./test/core/simd/simd_const.wast:37
+let $34 = instantiate(`(module (func (v128.const f32x4  1e38  1e38  1e38  1e38) drop))`);
+
+// ./test/core/simd/simd_const.wast:38
+let $35 = instantiate(`(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop))`);
+
+// ./test/core/simd/simd_const.wast:39
+let $36 = instantiate(`(module (func (v128.const f32x4  340282356779733623858607532500980858880 340282356779733623858607532500980858880
+                                 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop))`);
+
+// ./test/core/simd/simd_const.wast:41
+let $37 = instantiate(`(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880
+                                -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop))`);
+
+// ./test/core/simd/simd_const.wast:43
+let $38 = instantiate(`(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop))`);
+
+// ./test/core/simd/simd_const.wast:44
+let $39 = instantiate(`(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop))`);
+
+// ./test/core/simd/simd_const.wast:45
+let $40 = instantiate(`(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop))`);
+
+// ./test/core/simd/simd_const.wast:46
+let $41 = instantiate(`(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop))`);
+
+// ./test/core/simd/simd_const.wast:47
+let $42 = instantiate(`(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:48
+let $43 = instantiate(`(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:49
+let $44 = instantiate(`(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop))`);
+
+// ./test/core/simd/simd_const.wast:50
+let $45 = instantiate(`(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop))`);
+
+// ./test/core/simd/simd_const.wast:51
+let $46 = instantiate(`(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:52
+let $47 = instantiate(`(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:53
+let $48 = instantiate(`(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop))`);
+
+// ./test/core/simd/simd_const.wast:54
+let $49 = instantiate(`(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop))`);
+
+// ./test/core/simd/simd_const.wast:55
+let $50 = instantiate(`(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:56
+let $51 = instantiate(`(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:57
+let $52 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop))`);
+
+// ./test/core/simd/simd_const.wast:58
+let $53 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop))`);
+
+// ./test/core/simd/simd_const.wast:59
+let $54 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:60
+let $55 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:61
+let $56 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop))`);
+
+// ./test/core/simd/simd_const.wast:62
+let $57 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop))`);
+
+// ./test/core/simd/simd_const.wast:63
+let $58 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:64
+let $59 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:65
+let $60 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop))`);
+
+// ./test/core/simd/simd_const.wast:66
+let $61 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop))`);
+
+// ./test/core/simd/simd_const.wast:67
+let $62 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:68
+let $63 = instantiate(`(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:69
+let $64 = instantiate(`(module (func (v128.const f64x2  0x1p1023  0x1p1023) drop))`);
+
+// ./test/core/simd/simd_const.wast:70
+let $65 = instantiate(`(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop))`);
+
+// ./test/core/simd/simd_const.wast:71
+let $66 = instantiate(`(module (func (v128.const f64x2  1e308  1e308) drop))`);
+
+// ./test/core/simd/simd_const.wast:72
+let $67 = instantiate(`(module (func (v128.const f64x2 -1e308 -1e308) drop))`);
+
+// ./test/core/simd/simd_const.wast:73
+let $68 = instantiate(`(module (func (v128.const f64x2  179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))`);
+
+// ./test/core/simd/simd_const.wast:75
+let $69 = instantiate(`(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))`);
+
+// ./test/core/simd/simd_const.wast:77
+let $70 = instantiate(`(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop))`);
+
+// ./test/core/simd/simd_const.wast:78
+let $71 = instantiate(`(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop))`);
+
+// ./test/core/simd/simd_const.wast:79
+let $72 = instantiate(`(module (func (v128.const f64x2 0123456789 0123456789) drop))`);
+
+// ./test/core/simd/simd_const.wast:80
+let $73 = instantiate(`(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop))`);
+
+// ./test/core/simd/simd_const.wast:81
+let $74 = instantiate(`(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:82
+let $75 = instantiate(`(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:83
+let $76 = instantiate(`(module (func (v128.const f64x2 0123456789. 0123456789.) drop))`);
+
+// ./test/core/simd/simd_const.wast:84
+let $77 = instantiate(`(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop))`);
+
+// ./test/core/simd/simd_const.wast:85
+let $78 = instantiate(`(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:86
+let $79 = instantiate(`(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:87
+let $80 = instantiate(`(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop))`);
+
+// ./test/core/simd/simd_const.wast:88
+let $81 = instantiate(`(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop))`);
+
+// ./test/core/simd/simd_const.wast:89
+let $82 = instantiate(`(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:90
+let $83 = instantiate(`(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:91
+let $84 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop))`);
+
+// ./test/core/simd/simd_const.wast:92
+let $85 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop))`);
+
+// ./test/core/simd/simd_const.wast:93
+let $86 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:94
+let $87 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:95
+let $88 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop))`);
+
+// ./test/core/simd/simd_const.wast:96
+let $89 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop))`);
+
+// ./test/core/simd/simd_const.wast:97
+let $90 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:98
+let $91 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:99
+let $92 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))`);
+
+// ./test/core/simd/simd_const.wast:100
+let $93 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))`);
+
+// ./test/core/simd/simd_const.wast:101
+let $94 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))`);
+
+// ./test/core/simd/simd_const.wast:102
+let $95 = instantiate(`(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))`);
+
+// ./test/core/simd/simd_const.wast:106
+let $96 = instantiate(`(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))`);
+
+// ./test/core/simd/simd_const.wast:108
+let $97 = instantiate(`(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))`);
+
+// ./test/core/simd/simd_const.wast:110
+let $98 = instantiate(`(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80  -128  -128  -128  -128) drop))`);
+
+// ./test/core/simd/simd_const.wast:112
+let $99 = instantiate(`(module (func (v128.const i16x8 0xFF 0xFF  0xFF  0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop))`);
+
+// ./test/core/simd/simd_const.wast:113
+let $100 = instantiate(`(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop))`);
+
+// ./test/core/simd/simd_const.wast:114
+let $101 = instantiate(`(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000  -32768  -32768) drop))`);
+
+// ./test/core/simd/simd_const.wast:115
+let $102 = instantiate(`(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop))`);
+
+// ./test/core/simd/simd_const.wast:116
+let $103 = instantiate(`(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop))`);
+
+// ./test/core/simd/simd_const.wast:117
+let $104 = instantiate(`(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop))`);
+
+// ./test/core/simd/simd_const.wast:118
+let $105 = instantiate(`(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop))`);
+
+// ./test/core/simd/simd_const.wast:119
+let $106 = instantiate(`(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop))`);
+
+// ./test/core/simd/simd_const.wast:120
+let $107 = instantiate(`(module (func (v128.const f32x4 nan -nan inf -inf) drop))`);
+
+// ./test/core/simd/simd_const.wast:121
+let $108 = instantiate(`(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop))`);
+
+// ./test/core/simd/simd_const.wast:122
+let $109 = instantiate(`(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop))`);
+
+// ./test/core/simd/simd_const.wast:123
+let $110 = instantiate(`(module (func (v128.const f64x2 0x1p1023 -1e308) drop))`);
+
+// ./test/core/simd/simd_const.wast:124
+let $111 = instantiate(`(module (func (v128.const f64x2 nan -inf) drop))`);
+
+// ./test/core/simd/simd_const.wast:128
+let $112 = instantiate(`(module (memory 1))`);
+
+// ./test/core/simd/simd_const.wast:129
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_const.wast:133
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_const.wast:137
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_const.wast:141
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_const.wast:145
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:149
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:153
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:157
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:161
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4  0x100000000  0x100000000  0x100000000  0x100000000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:165
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:169
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4  4294967296  4294967296  4294967296  4294967296) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:173
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:177
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4  0x1p128  0x1p128  0x1p128  0x1p128) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:181
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:185
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4  1e39  1e39  1e39  1e39) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:189
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:193
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4  340282356779733661637539395458142568448 340282356779733661637539395458142568448                          340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:198
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448                         -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:204
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:209
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2  269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552                          269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:214
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552                         -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:220
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:226
+assert_malformed(() => instantiate(`(func (v128.const) drop) `), `unexpected token`);
+
+// ./test/core/simd/simd_const.wast:231
+assert_malformed(
+  () => instantiate(`(func (v128.const 0 0 0 0) drop) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_const.wast:235
+assert_malformed(
+  () => instantiate(`(func (v128.const i8x16) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:239
+assert_malformed(
+  () => instantiate(`(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:243
+assert_malformed(
+  () => instantiate(`(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:247
+assert_malformed(
+  () => instantiate(`(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:252
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:256
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:260
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:264
+assert_malformed(
+  () => instantiate(`(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:269
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:273
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 0x 0x 0x 0x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:277
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 1x 1x 1x 1x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:281
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:286
+assert_malformed(
+  () => instantiate(`(func (v128.const i64x2) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:290
+assert_malformed(
+  () => instantiate(`(func (v128.const i64x2 0x 0x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:294
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 1x 1x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:298
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0xg 0xg) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:303
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:307
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 .0 .0 .0 .0) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:311
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:315
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0e 0e 0e 0e) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:319
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:323
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:327
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:331
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x 0x 0x 0x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:335
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 1x 1x 1x 1x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:339
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:343
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:347
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:351
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:355
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:359
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:363
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:367
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:371
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:375
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:379
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:383
+assert_malformed(
+  () => instantiate(`(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:388
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:392
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 .0 .0) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:396
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 .0e0 .0e0) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:400
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0e 0e) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:404
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0e+ 0e+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:408
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0.0e+ 0.0e+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:412
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0.0e- 0.0e-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:416
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x 0x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:420
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 1x 1x) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:424
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0xg 0xg) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:428
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x. 0x.) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:432
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0.g 0x0.g) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:436
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0p 0x0p) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:440
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0p+ 0x0p+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:444
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0p- 0x0p-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:448
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0.0p 0x0.0p) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:452
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:456
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:460
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 0x0pA 0x0pA) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:464
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 nan:1 nan:1) drop) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:468
+assert_malformed(
+  () => instantiate(`(func (v128.const f64x2 nan:0x0 nan:0x0) drop) `),
+  `constant out of range`,
+);
+
+// ./test/core/simd/simd_const.wast:475
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:481
+assert_malformed(
+  () => instantiate(`(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop) `),
+  `wrong number of lane literals`,
+);
+
+// ./test/core/simd/simd_const.wast:489
+let $113 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50)))`);
+
+// ./test/core/simd/simd_const.wast:490
+assert_return(
+  () => invoke($113, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:491
+let $114 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50)))`);
+
+// ./test/core/simd/simd_const.wast:492
+assert_return(
+  () => invoke($114, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:493
+let $115 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50)))`);
+
+// ./test/core/simd/simd_const.wast:494
+assert_return(
+  () => invoke($115, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000008881787),
+      value("f32", 0.0000000000000008881787),
+      value("f32", 0.0000000000000008881787),
+      value("f32", 0.0000000000000008881787),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:495
+let $116 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50)))`);
+
+// ./test/core/simd/simd_const.wast:496
+assert_return(
+  () => invoke($116, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.0000000000000008881787),
+      value("f32", -0.0000000000000008881787),
+      value("f32", -0.0000000000000008881787),
+      value("f32", -0.0000000000000008881787),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:498
+let $117 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64)))`);
+
+// ./test/core/simd/simd_const.wast:499
+assert_return(
+  () => invoke($117, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:500
+let $118 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64)))`);
+
+// ./test/core/simd/simd_const.wast:501
+assert_return(
+  () => invoke($118, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:502
+let $119 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64)))`);
+
+// ./test/core/simd/simd_const.wast:503
+assert_return(
+  () => invoke($119, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000008881787),
+      value("f32", 0.0000000000000008881787),
+      value("f32", 0.0000000000000008881787),
+      value("f32", 0.0000000000000008881787),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:504
+let $120 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64)))`);
+
+// ./test/core/simd/simd_const.wast:505
+assert_return(
+  () => invoke($120, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.0000000000000008881787),
+      value("f32", -0.0000000000000008881787),
+      value("f32", -0.0000000000000008881787),
+      value("f32", -0.0000000000000008881787),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:507
+let $121 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16)))`);
+
+// ./test/core/simd/simd_const.wast:508
+assert_return(
+  () => invoke($121, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+      value("f32", 0.0000000000000008881784),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:509
+let $122 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16)))`);
+
+// ./test/core/simd/simd_const.wast:510
+assert_return(
+  () => invoke($122, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+      value("f32", -0.0000000000000008881784),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:511
+let $123 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16)))`);
+
+// ./test/core/simd/simd_const.wast:512
+assert_return(
+  () => invoke($123, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000008881786),
+      value("f32", 0.0000000000000008881786),
+      value("f32", 0.0000000000000008881786),
+      value("f32", 0.0000000000000008881786),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:513
+let $124 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16)))`);
+
+// ./test/core/simd/simd_const.wast:514
+assert_return(
+  () => invoke($124, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.0000000000000008881786),
+      value("f32", -0.0000000000000008881786),
+      value("f32", -0.0000000000000008881786),
+      value("f32", -0.0000000000000008881786),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:517
+let $125 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50)))`);
+
+// ./test/core/simd/simd_const.wast:518
+assert_return(
+  () => invoke($125, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:519
+let $126 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50)))`);
+
+// ./test/core/simd/simd_const.wast:520
+assert_return(
+  () => invoke($126, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:521
+let $127 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50)))`);
+
+// ./test/core/simd/simd_const.wast:522
+assert_return(
+  () => invoke($127, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1125900300000000),
+      value("f32", 1125900300000000),
+      value("f32", 1125900300000000),
+      value("f32", 1125900300000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:523
+let $128 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50)))`);
+
+// ./test/core/simd/simd_const.wast:524
+assert_return(
+  () => invoke($128, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -1125900300000000),
+      value("f32", -1125900300000000),
+      value("f32", -1125900300000000),
+      value("f32", -1125900300000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:526
+let $129 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000)))`);
+
+// ./test/core/simd/simd_const.wast:527
+assert_return(
+  () => invoke($129, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:528
+let $130 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000)))`);
+
+// ./test/core/simd/simd_const.wast:529
+assert_return(
+  () => invoke($130, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:530
+let $131 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000)))`);
+
+// ./test/core/simd/simd_const.wast:531
+assert_return(
+  () => invoke($131, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1125900200000000),
+      value("f32", 1125900200000000),
+      value("f32", 1125900200000000),
+      value("f32", 1125900200000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:532
+let $132 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000)))`);
+
+// ./test/core/simd/simd_const.wast:533
+assert_return(
+  () => invoke($132, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -1125900200000000),
+      value("f32", -1125900200000000),
+      value("f32", -1125900200000000),
+      value("f32", -1125900200000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:535
+let $133 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488)))`);
+
+// ./test/core/simd/simd_const.wast:536
+assert_return(
+  () => invoke($133, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+      value("f32", 1125899900000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:537
+let $134 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488)))`);
+
+// ./test/core/simd/simd_const.wast:538
+assert_return(
+  () => invoke($134, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+      value("f32", -1125899900000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:539
+let $135 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216)))`);
+
+// ./test/core/simd/simd_const.wast:540
+assert_return(
+  () => invoke($135, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1125900200000000),
+      value("f32", 1125900200000000),
+      value("f32", 1125900200000000),
+      value("f32", 1125900200000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:541
+let $136 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216)))`);
+
+// ./test/core/simd/simd_const.wast:542
+assert_return(
+  () => invoke($136, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -1125900200000000),
+      value("f32", -1125900200000000),
+      value("f32", -1125900200000000),
+      value("f32", -1125900200000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:545
+let $137 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126)))`);
+
+// ./test/core/simd/simd_const.wast:546
+assert_return(
+  () => invoke($137, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:547
+let $138 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))`);
+
+// ./test/core/simd/simd_const.wast:548
+assert_return(
+  () => invoke($138, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:549
+let $139 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))`);
+
+// ./test/core/simd/simd_const.wast:550
+assert_return(
+  () => invoke($139, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000004),
+      value("f32", 0.000000000000000000000000000000000000000000004),
+      value("f32", 0.000000000000000000000000000000000000000000004),
+      value("f32", 0.000000000000000000000000000000000000000000004),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:551
+let $140 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126)))`);
+
+// ./test/core/simd/simd_const.wast:552
+assert_return(
+  () => invoke($140, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000004),
+      value("f32", -0.000000000000000000000000000000000000000000004),
+      value("f32", -0.000000000000000000000000000000000000000000004),
+      value("f32", -0.000000000000000000000000000000000000000000004),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:555
+let $141 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127)))`);
+
+// ./test/core/simd/simd_const.wast:556
+assert_return(
+  () => invoke($141, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:557
+let $142 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127)))`);
+
+// ./test/core/simd/simd_const.wast:558
+assert_return(
+  () => invoke($142, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:559
+let $143 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127)))`);
+
+// ./test/core/simd/simd_const.wast:560
+assert_return(
+  () => invoke($143, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:561
+let $144 = instantiate(`(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127)))`);
+
+// ./test/core/simd/simd_const.wast:562
+assert_return(
+  () => invoke($144, `f`, []),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:565
+let $145 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:566
+assert_return(
+  () => invoke($145, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:567
+let $146 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:568
+assert_return(
+  () => invoke($146, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:569
+let $147 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:570
+assert_return(
+  () => invoke($147, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:571
+let $148 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:572
+assert_return(
+  () => invoke($148, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:573
+let $149 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:574
+assert_return(
+  () => invoke($149, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:575
+let $150 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:576
+assert_return(
+  () => invoke($150, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:577
+let $151 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:578
+assert_return(
+  () => invoke($151, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:579
+let $152 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:580
+assert_return(
+  () => invoke($152, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:581
+let $153 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:582
+assert_return(
+  () => invoke($153, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:583
+let $154 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:584
+assert_return(
+  () => invoke($154, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:585
+let $155 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:586
+assert_return(
+  () => invoke($155, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:587
+let $156 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:588
+assert_return(
+  () => invoke($156, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:589
+let $157 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:590
+assert_return(
+  () => invoke($157, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:591
+let $158 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:592
+assert_return(
+  () => invoke($158, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:593
+let $159 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:594
+assert_return(
+  () => invoke($159, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:595
+let $160 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:596
+assert_return(
+  () => invoke($160, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:597
+let $161 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:598
+assert_return(
+  () => invoke($161, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:599
+let $162 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:600
+assert_return(
+  () => invoke($162, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:601
+let $163 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:602
+assert_return(
+  () => invoke($163, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:603
+let $164 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))`);
+
+// ./test/core/simd/simd_const.wast:604
+assert_return(
+  () => invoke($164, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:605
+let $165 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:606
+assert_return(
+  () => invoke($165, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:607
+let $166 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:608
+assert_return(
+  () => invoke($166, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:609
+let $167 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:610
+assert_return(
+  () => invoke($167, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:611
+let $168 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))`);
+
+// ./test/core/simd/simd_const.wast:612
+assert_return(
+  () => invoke($168, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:613
+let $169 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:614
+assert_return(
+  () => invoke($169, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:615
+let $170 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))`);
+
+// ./test/core/simd/simd_const.wast:616
+assert_return(
+  () => invoke($170, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:617
+let $171 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:618
+assert_return(
+  () => invoke($171, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:619
+let $172 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:620
+assert_return(
+  () => invoke($172, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102884),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:621
+let $173 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:622
+assert_return(
+  () => invoke($173, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:623
+let $174 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:624
+assert_return(
+  () => invoke($174, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:625
+let $175 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:626
+assert_return(
+  () => invoke($175, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:627
+let $176 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:628
+assert_return(
+  () => invoke($176, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:629
+let $177 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:630
+assert_return(
+  () => invoke($177, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:631
+let $178 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:632
+assert_return(
+  () => invoke($178, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:633
+let $179 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:634
+assert_return(
+  () => invoke($179, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:635
+let $180 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:636
+assert_return(
+  () => invoke($180, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:637
+let $181 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:638
+assert_return(
+  () => invoke($181, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:639
+let $182 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:640
+assert_return(
+  () => invoke($182, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028847),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:641
+let $183 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:642
+assert_return(
+  () => invoke($183, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:643
+let $184 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:644
+assert_return(
+  () => invoke($184, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:645
+let $185 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:646
+assert_return(
+  () => invoke($185, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:647
+let $186 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:648
+assert_return(
+  () => invoke($186, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:649
+let $187 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:650
+assert_return(
+  () => invoke($187, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:651
+let $188 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:652
+assert_return(
+  () => invoke($188, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:653
+let $189 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:654
+assert_return(
+  () => invoke($189, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:655
+let $190 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))`);
+
+// ./test/core/simd/simd_const.wast:656
+assert_return(
+  () => invoke($190, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:657
+let $191 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:658
+assert_return(
+  () => invoke($191, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:659
+let $192 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:660
+assert_return(
+  () => invoke($192, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:661
+let $193 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:662
+assert_return(
+  () => invoke($193, `f`, []),
+  [
+    value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:663
+let $194 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))`);
+
+// ./test/core/simd/simd_const.wast:664
+assert_return(
+  () => invoke($194, `f`, []),
+  [
+    value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002409919865102885),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:665
+let $195 = instantiate(`(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:666
+assert_return(
+  () => invoke($195, `f`, []),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:667
+let $196 = instantiate(`(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))`);
+
+// ./test/core/simd/simd_const.wast:668
+assert_return(
+  () => invoke($196, `f`, []),
+  [
+    value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024099198651028857),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:669
+let $197 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))`);
+
+// ./test/core/simd/simd_const.wast:670
+assert_return(
+  () => invoke($197, `f`, []),
+  [
+    value("f64", 5357543035931337000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:671
+let $198 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))`);
+
+// ./test/core/simd/simd_const.wast:672
+assert_return(
+  () => invoke($198, `f`, []),
+  [
+    value("f64", -5357543035931337000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:673
+let $199 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))`);
+
+// ./test/core/simd/simd_const.wast:674
+assert_return(
+  () => invoke($199, `f`, []),
+  [
+    value("f64", 5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:675
+let $200 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))`);
+
+// ./test/core/simd/simd_const.wast:676
+assert_return(
+  () => invoke($200, `f`, []),
+  [
+    value("f64", -5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:677
+let $201 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))`);
+
+// ./test/core/simd/simd_const.wast:678
+assert_return(
+  () => invoke($201, `f`, []),
+  [
+    value("f64", 5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:679
+let $202 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))`);
+
+// ./test/core/simd/simd_const.wast:680
+assert_return(
+  () => invoke($202, `f`, []),
+  [
+    value("f64", -5357543035931338000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:681
+let $203 = instantiate(`(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))`);
+
+// ./test/core/simd/simd_const.wast:682
+assert_return(
+  () => invoke($203, `f`, []),
+  [
+    value("f64", 5357543035931339000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:683
+let $204 = instantiate(`(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))`);
+
+// ./test/core/simd/simd_const.wast:684
+assert_return(
+  () => invoke($204, `f`, []),
+  [
+    value("f64", -5357543035931339000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:687
+let $205 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:688
+assert_return(
+  () => invoke($205, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880993000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880993000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:689
+let $206 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:690
+assert_return(
+  () => invoke($206, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880993000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880993000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:691
+let $207 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:692
+assert_return(
+  () => invoke($207, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:693
+let $208 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:694
+assert_return(
+  () => invoke($208, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:695
+let $209 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:696
+assert_return(
+  () => invoke($209, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:697
+let $210 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:698
+assert_return(
+  () => invoke($210, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:699
+let $211 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:700
+assert_return(
+  () => invoke($211, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:701
+let $212 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:702
+assert_return(
+  () => invoke($212, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:703
+let $213 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:704
+assert_return(
+  () => invoke($213, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:705
+let $214 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:706
+assert_return(
+  () => invoke($214, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:707
+let $215 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:708
+assert_return(
+  () => invoke($215, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:709
+let $216 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:710
+assert_return(
+  () => invoke($216, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880994000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:711
+let $217 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:712
+assert_return(
+  () => invoke($217, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:713
+let $218 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:714
+assert_return(
+  () => invoke($218, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:715
+let $219 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:716
+assert_return(
+  () => invoke($219, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:717
+let $220 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:718
+assert_return(
+  () => invoke($220, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:719
+let $221 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:720
+assert_return(
+  () => invoke($221, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:721
+let $222 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:722
+assert_return(
+  () => invoke($222, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:723
+let $223 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:724
+assert_return(
+  () => invoke($223, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:725
+let $224 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:726
+assert_return(
+  () => invoke($224, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:727
+let $225 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:728
+assert_return(
+  () => invoke($225, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:729
+let $226 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:730
+assert_return(
+  () => invoke($226, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:731
+let $227 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:732
+assert_return(
+  () => invoke($227, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:733
+let $228 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600)))`);
+
+// ./test/core/simd/simd_const.wast:734
+assert_return(
+  () => invoke($228, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:735
+let $229 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:736
+assert_return(
+  () => invoke($229, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:737
+let $230 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600)))`);
+
+// ./test/core/simd/simd_const.wast:738
+assert_return(
+  () => invoke($230, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880995000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:739
+let $231 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:740
+assert_return(
+  () => invoke($231, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 4149515568880996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 4149515568880996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:741
+let $232 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600)))`);
+
+// ./test/core/simd/simd_const.wast:742
+assert_return(
+  () => invoke($232, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -4149515568880996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -4149515568880996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:743
+let $233 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000)))`);
+
+// ./test/core/simd/simd_const.wast:744
+assert_return(
+  () => invoke($233, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528680000000000000),
+      value("f64", 158456325028528680000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:745
+let $234 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000)))`);
+
+// ./test/core/simd/simd_const.wast:746
+assert_return(
+  () => invoke($234, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528680000000000000),
+      value("f64", -158456325028528680000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:747
+let $235 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001)))`);
+
+// ./test/core/simd/simd_const.wast:748
+assert_return(
+  () => invoke($235, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528700000000000000),
+      value("f64", 158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:749
+let $236 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001)))`);
+
+// ./test/core/simd/simd_const.wast:750
+assert_return(
+  () => invoke($236, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528700000000000000),
+      value("f64", -158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:751
+let $237 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:752
+assert_return(
+  () => invoke($237, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528700000000000000),
+      value("f64", 158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:753
+let $238 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:754
+assert_return(
+  () => invoke($238, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528700000000000000),
+      value("f64", -158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:755
+let $239 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000)))`);
+
+// ./test/core/simd/simd_const.wast:756
+assert_return(
+  () => invoke($239, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528700000000000000),
+      value("f64", 158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:757
+let $240 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000)))`);
+
+// ./test/core/simd/simd_const.wast:758
+assert_return(
+  () => invoke($240, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528700000000000000),
+      value("f64", -158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:759
+let $241 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001)))`);
+
+// ./test/core/simd/simd_const.wast:760
+assert_return(
+  () => invoke($241, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528700000000000000),
+      value("f64", 158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:761
+let $242 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001)))`);
+
+// ./test/core/simd/simd_const.wast:762
+assert_return(
+  () => invoke($242, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528700000000000000),
+      value("f64", -158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:763
+let $243 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:764
+assert_return(
+  () => invoke($243, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528700000000000000),
+      value("f64", 158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:765
+let $244 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:766
+assert_return(
+  () => invoke($244, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528700000000000000),
+      value("f64", -158456325028528700000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:767
+let $245 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000)))`);
+
+// ./test/core/simd/simd_const.wast:768
+assert_return(
+  () => invoke($245, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:769
+let $246 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000)))`);
+
+// ./test/core/simd/simd_const.wast:770
+assert_return(
+  () => invoke($246, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:771
+let $247 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001)))`);
+
+// ./test/core/simd/simd_const.wast:772
+assert_return(
+  () => invoke($247, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:773
+let $248 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001)))`);
+
+// ./test/core/simd/simd_const.wast:774
+assert_return(
+  () => invoke($248, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:775
+let $249 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:776
+assert_return(
+  () => invoke($249, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:777
+let $250 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:778
+assert_return(
+  () => invoke($250, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:779
+let $251 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000)))`);
+
+// ./test/core/simd/simd_const.wast:780
+assert_return(
+  () => invoke($251, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:781
+let $252 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000)))`);
+
+// ./test/core/simd/simd_const.wast:782
+assert_return(
+  () => invoke($252, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:783
+let $253 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001)))`);
+
+// ./test/core/simd/simd_const.wast:784
+assert_return(
+  () => invoke($253, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:785
+let $254 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001)))`);
+
+// ./test/core/simd/simd_const.wast:786
+assert_return(
+  () => invoke($254, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:787
+let $255 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:788
+assert_return(
+  () => invoke($255, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:789
+let $256 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff)))`);
+
+// ./test/core/simd/simd_const.wast:790
+assert_return(
+  () => invoke($256, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:791
+let $257 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000)))`);
+
+// ./test/core/simd/simd_const.wast:792
+assert_return(
+  () => invoke($257, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528750000000000000),
+      value("f64", 158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:793
+let $258 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000)))`);
+
+// ./test/core/simd/simd_const.wast:794
+assert_return(
+  () => invoke($258, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528750000000000000),
+      value("f64", -158456325028528750000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:795
+let $259 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001)))`);
+
+// ./test/core/simd/simd_const.wast:796
+assert_return(
+  () => invoke($259, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 158456325028528780000000000000),
+      value("f64", 158456325028528780000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:797
+let $260 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001)))`);
+
+// ./test/core/simd/simd_const.wast:798
+assert_return(
+  () => invoke($260, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -158456325028528780000000000000),
+      value("f64", -158456325028528780000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:799
+let $261 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104)))`);
+
+// ./test/core/simd/simd_const.wast:800
+assert_return(
+  () => invoke($261, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 1152921504606847000),
+      value("f64", 1152921504606847000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:801
+let $262 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104)))`);
+
+// ./test/core/simd/simd_const.wast:802
+assert_return(
+  () => invoke($262, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -1152921504606847000),
+      value("f64", -1152921504606847000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:803
+let $263 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105)))`);
+
+// ./test/core/simd/simd_const.wast:804
+assert_return(
+  () => invoke($263, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 1152921504606847200),
+      value("f64", 1152921504606847200),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:805
+let $264 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105)))`);
+
+// ./test/core/simd/simd_const.wast:806
+assert_return(
+  () => invoke($264, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -1152921504606847200),
+      value("f64", -1152921504606847200),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:807
+let $265 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359)))`);
+
+// ./test/core/simd/simd_const.wast:808
+assert_return(
+  () => invoke($265, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 1152921504606847200),
+      value("f64", 1152921504606847200),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:809
+let $266 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359)))`);
+
+// ./test/core/simd/simd_const.wast:810
+assert_return(
+  () => invoke($266, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -1152921504606847200),
+      value("f64", -1152921504606847200),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:811
+let $267 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360)))`);
+
+// ./test/core/simd/simd_const.wast:812
+assert_return(
+  () => invoke($267, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 1152921504606847500),
+      value("f64", 1152921504606847500),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:813
+let $268 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360)))`);
+
+// ./test/core/simd/simd_const.wast:814
+assert_return(
+  () => invoke($268, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -1152921504606847500),
+      value("f64", -1152921504606847500),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:817
+let $269 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:818
+assert_return(() => invoke($269, `f`, []), [new F64x2Pattern(value("f64", 0), value("f64", 0))]);
+
+// ./test/core/simd/simd_const.wast:819
+let $270 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:820
+assert_return(() => invoke($270, `f`, []), [new F64x2Pattern(value("f64", -0), value("f64", -0))]);
+
+// ./test/core/simd/simd_const.wast:821
+let $271 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:822
+assert_return(
+  () => invoke($271, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:823
+let $272 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:824
+assert_return(
+  () => invoke($272, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:825
+let $273 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:826
+assert_return(
+  () => invoke($273, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:827
+let $274 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:828
+assert_return(
+  () => invoke($274, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:829
+let $275 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:830
+assert_return(
+  () => invoke($275, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:831
+let $276 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:832
+assert_return(
+  () => invoke($276, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:833
+let $277 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:834
+assert_return(
+  () => invoke($277, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:835
+let $278 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:836
+assert_return(
+  () => invoke($278, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:837
+let $279 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:838
+assert_return(
+  () => invoke($279, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:839
+let $280 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:840
+assert_return(
+  () => invoke($280, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:841
+let $281 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:842
+assert_return(
+  () => invoke($281, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:843
+let $282 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:844
+assert_return(
+  () => invoke($282, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:845
+let $283 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:846
+assert_return(
+  () => invoke($283, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:847
+let $284 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:848
+assert_return(
+  () => invoke($284, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:849
+let $285 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:850
+assert_return(
+  () => invoke($285, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:851
+let $286 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:852
+assert_return(
+  () => invoke($286, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:853
+let $287 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:854
+assert_return(
+  () => invoke($287, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:855
+let $288 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:856
+assert_return(
+  () => invoke($288, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:857
+let $289 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:858
+assert_return(
+  () => invoke($289, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:859
+let $290 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:860
+assert_return(
+  () => invoke($290, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:861
+let $291 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:862
+assert_return(
+  () => invoke($291, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:863
+let $292 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022)))`);
+
+// ./test/core/simd/simd_const.wast:864
+assert_return(
+  () => invoke($292, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:865
+let $293 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:866
+assert_return(
+  () => invoke($293, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:867
+let $294 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:868
+assert_return(
+  () => invoke($294, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:869
+let $295 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:870
+assert_return(
+  () => invoke($295, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507203),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507203),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:871
+let $296 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022)))`);
+
+// ./test/core/simd/simd_const.wast:872
+assert_return(
+  () => invoke($296, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507203),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507203),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:875
+let $297 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023)))`);
+
+// ./test/core/simd/simd_const.wast:876
+assert_return(
+  () => invoke($297, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:877
+let $298 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023)))`);
+
+// ./test/core/simd/simd_const.wast:878
+assert_return(
+  () => invoke($298, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:879
+let $299 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023)))`);
+
+// ./test/core/simd/simd_const.wast:880
+assert_return(
+  () => invoke($299, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:881
+let $300 = instantiate(`(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023)))`);
+
+// ./test/core/simd/simd_const.wast:882
+assert_return(
+  () => invoke($300, `f`, []),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:886
+let $301 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_const.wast:971
+assert_return(
+  () => invoke($301, `as-br-retval`, []),
+  [i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c])],
+);
+
+// ./test/core/simd/simd_const.wast:972
+assert_return(() => invoke($301, `as-br_if-retval`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:973
+assert_return(() => invoke($301, `as-return-retval`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:974
+assert_return(() => invoke($301, `as-if-then-retval`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:975
+assert_return(() => invoke($301, `as-if-else-retval`, []), [i32x4([0x3, 0x2, 0x1, 0x0])]);
+
+// ./test/core/simd/simd_const.wast:976
+assert_return(() => invoke($301, `as-call-param`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:977
+assert_return(() => invoke($301, `as-call_indirect-param`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:978
+assert_return(() => invoke($301, `as-block-retval`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:979
+assert_return(() => invoke($301, `as-loop-retval`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:980
+assert_return(() => invoke($301, `as-drop-operand`, []), []);
+
+// ./test/core/simd/simd_const.wast:982
+assert_return(() => invoke($301, `as-br-retval2`, []), [i64x2([0x302010007060504n, 0xb0a09080f0e0d0cn])]);
+
+// ./test/core/simd/simd_const.wast:983
+assert_return(() => invoke($301, `as-br_if-retval2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:984
+assert_return(() => invoke($301, `as-return-retval2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:985
+assert_return(() => invoke($301, `as-if-then-retval2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:986
+assert_return(() => invoke($301, `as-if-else-retval2`, []), [i64x2([0x1n, 0x0n])]);
+
+// ./test/core/simd/simd_const.wast:987
+assert_return(() => invoke($301, `as-call-param2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:988
+assert_return(() => invoke($301, `as-call_indirect-param2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:989
+assert_return(() => invoke($301, `as-block-retval2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:990
+assert_return(() => invoke($301, `as-loop-retval2`, []), [i64x2([0x0n, 0x1n])]);
+
+// ./test/core/simd/simd_const.wast:991
+assert_return(() => invoke($301, `as-drop-operand2`, []), []);
+
+// ./test/core/simd/simd_const.wast:995
+let $302 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_const.wast:1023
+assert_return(
+  () => invoke($302, `as-local.set/get-value_0_0`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_const.wast:1024
+assert_return(
+  () => invoke($302, `as-local.set/get-value_0_1`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_const.wast:1025
+assert_return(
+  () => invoke($302, `as-local.set/get-value_3_0`, [i32x4([0x2, 0x2, 0x2, 0x2])]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_const.wast:1026
+assert_return(() => invoke($302, `as-local.tee-value`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:1031
+let $303 = instantiate(`(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)
+  )
+)`);
+
+// ./test/core/simd/simd_const.wast:1064
+assert_return(
+  () => invoke($303, `as-global.set_value_$$g0_$$g1_$$g2_$$g3`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+    i32x4([0x3, 0x3, 0x3, 0x3]),
+    i32x4([0x4, 0x4, 0x4, 0x4]),
+  ]),
+  [],
+);
+
+// ./test/core/simd/simd_const.wast:1068
+assert_return(() => invoke($303, `global.get_g0`, []), [i32x4([0x1, 0x1, 0x1, 0x1])]);
+
+// ./test/core/simd/simd_const.wast:1069
+assert_return(() => invoke($303, `global.get_g1`, []), [i32x4([0x2, 0x2, 0x2, 0x2])]);
+
+// ./test/core/simd/simd_const.wast:1070
+assert_return(() => invoke($303, `global.get_g2`, []), [i32x4([0x3, 0x3, 0x3, 0x3])]);
+
+// ./test/core/simd/simd_const.wast:1071
+assert_return(() => invoke($303, `global.get_g3`, []), [i32x4([0x4, 0x4, 0x4, 0x4])]);
+
+// ./test/core/simd/simd_const.wast:1076
+let $304 = instantiate(`(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))
+)`);
+
+// ./test/core/simd/simd_const.wast:1104
+assert_return(() => invoke($304, `i32x4.test`, []), [i32x4([0xbadd00d, 0xbadd00d, 0xbadd00d, 0xbadd00d])]);
+
+// ./test/core/simd/simd_const.wast:1105
+assert_return(
+  () => invoke($304, `i32x4.smax`, []),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_const.wast:1106
+assert_return(
+  () => invoke($304, `i32x4.neg_smax`, []),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_const.wast:1107
+assert_return(
+  () => invoke($304, `i32x4.inc_smin`, []),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_const.wast:1108
+assert_return(() => invoke($304, `i32x4.neg_zero`, []), [i32x4([0x0, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_const.wast:1109
+assert_return(() => invoke($304, `i32x4.not_octal`, []), [i32x4([0xa, 0xa, 0xa, 0xa])]);
+
+// ./test/core/simd/simd_const.wast:1110
+assert_return(() => invoke($304, `i32x4.plus_sign`, []), [i32x4([0x2a, 0x2a, 0x2a, 0x2a])]);
+
+// ./test/core/simd/simd_const.wast:1112
+assert_return(() => invoke($304, `i32x4-dec-sep1`, []), [i32x4([0xf4240, 0xf4240, 0xf4240, 0xf4240])]);
+
+// ./test/core/simd/simd_const.wast:1113
+assert_return(() => invoke($304, `i32x4-dec-sep2`, []), [i32x4([0x3e8, 0x3e8, 0x3e8, 0x3e8])]);
+
+// ./test/core/simd/simd_const.wast:1114
+assert_return(
+  () => invoke($304, `i32x4-hex-sep1`, []),
+  [i32x4([0xa0f0099, 0xa0f0099, 0xa0f0099, 0xa0f0099])],
+);
+
+// ./test/core/simd/simd_const.wast:1115
+assert_return(() => invoke($304, `i32x4-hex-sep2`, []), [i32x4([0x1aa0f, 0x1aa0f, 0x1aa0f, 0x1aa0f])]);
+
+// ./test/core/simd/simd_const.wast:1117
+assert_return(() => invoke($304, `i64x2.test`, []), [i64x2([0xbadd00d0badd00dn, 0xbadd00d0badd00dn])]);
+
+// ./test/core/simd/simd_const.wast:1118
+assert_return(() => invoke($304, `i64x2.smax`, []), [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])]);
+
+// ./test/core/simd/simd_const.wast:1119
+assert_return(
+  () => invoke($304, `i64x2.neg_smax`, []),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_const.wast:1120
+assert_return(
+  () => invoke($304, `i64x2.inc_smin`, []),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_const.wast:1121
+assert_return(() => invoke($304, `i64x2.neg_zero`, []), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_const.wast:1122
+assert_return(() => invoke($304, `i64x2.not_octal`, []), [i64x2([0x271an, 0x271an])]);
+
+// ./test/core/simd/simd_const.wast:1123
+assert_return(() => invoke($304, `i64x2.plus_sign`, []), [i64x2([0x2an, 0x2an])]);
+
+// ./test/core/simd/simd_const.wast:1125
+assert_return(() => invoke($304, `i64x2-dec-sep1`, []), [i64x2([0x9184e72a000n, 0x9184e72a000n])]);
+
+// ./test/core/simd/simd_const.wast:1126
+assert_return(() => invoke($304, `i64x2-dec-sep2`, []), [i64x2([0x989680n, 0x989680n])]);
+
+// ./test/core/simd/simd_const.wast:1127
+assert_return(() => invoke($304, `i64x2-hex-sep1`, []), [i64x2([0xa0f00990a0f0099n, 0xa0f00990a0f0099n])]);
+
+// ./test/core/simd/simd_const.wast:1128
+assert_return(() => invoke($304, `i64x2-hex-sep2`, []), [i64x2([0x1aa0f1aa0fn, 0x1aa0f1aa0fn])]);
+
+// ./test/core/simd/simd_const.wast:1130
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 _100 _100 _100 _100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1134
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1138
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1142
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 99_ 99_ 99_ 99_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1146
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1150
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1154
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1158
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1162
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1166
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1171
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 _100_100 _100_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1175
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 +_100_100 +_100_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1179
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 -_100_100 -_100_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1183
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 99_99_ 99_99_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1187
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 1__000_000 1__000_000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1191
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 _0x100000 _0x100000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1195
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 0_x100000 0_x100000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1199
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 0x_100000 0x_100000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1203
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 0x00_ 0x00_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1207
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1214
+let $305 = instantiate(`(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))
+)`);
+
+// ./test/core/simd/simd_const.wast:1237
+assert_return(
+  () => invoke($305, `f32-dec-sep1`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1000000),
+      value("f32", 1000000),
+      value("f32", 1000000),
+      value("f32", 1000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1238
+assert_return(
+  () => invoke($305, `f32-dec-sep2`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1000),
+      value("f32", 1000),
+      value("f32", 1000),
+      value("f32", 1000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1239
+assert_return(
+  () => invoke($305, `f32-dec-sep3`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1003.1416),
+      value("f32", 1003.1416),
+      value("f32", 1003.1416),
+      value("f32", 1003.1416),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1240
+assert_return(
+  () => invoke($305, `f32-dec-sep4`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 990000000000000),
+      value("f32", 990000000000000),
+      value("f32", 990000000000000),
+      value("f32", 990000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1241
+assert_return(
+  () => invoke($305, `f32-dec-sep5`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 12200012000000000000000000000),
+      value("f32", 12200012000000000000000000000),
+      value("f32", 12200012000000000000000000000),
+      value("f32", 12200012000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1242
+assert_return(
+  () => invoke($305, `f32-hex-sep1`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 168755360),
+      value("f32", 168755360),
+      value("f32", 168755360),
+      value("f32", 168755360),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1243
+assert_return(
+  () => invoke($305, `f32-hex-sep2`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 109071),
+      value("f32", 109071),
+      value("f32", 109071),
+      value("f32", 109071),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1244
+assert_return(
+  () => invoke($305, `f32-hex-sep3`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 41215.94),
+      value("f32", 41215.94),
+      value("f32", 41215.94),
+      value("f32", 41215.94),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1245
+assert_return(
+  () => invoke($305, `f32-hex-sep4`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 1966080),
+      value("f32", 1966080),
+      value("f32", 1966080),
+      value("f32", 1966080),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1246
+assert_return(
+  () => invoke($305, `f32-hex-sep5`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 23605224000000),
+      value("f32", 23605224000000),
+      value("f32", 23605224000000),
+      value("f32", 23605224000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1247
+assert_return(
+  () => invoke($305, `f64-dec-sep1`, []),
+  [new F64x2Pattern(value("f64", 1000000), value("f64", 1000000))],
+);
+
+// ./test/core/simd/simd_const.wast:1248
+assert_return(
+  () => invoke($305, `f64-dec-sep2`, []),
+  [new F64x2Pattern(value("f64", 1000), value("f64", 1000))],
+);
+
+// ./test/core/simd/simd_const.wast:1249
+assert_return(
+  () => invoke($305, `f64-dec-sep3`, []),
+  [new F64x2Pattern(value("f64", 1003.141592), value("f64", 1003.141592))],
+);
+
+// ./test/core/simd/simd_const.wast:1250
+assert_return(
+  () => invoke($305, `f64-dec-sep4`, []),
+  [
+    new F64x2Pattern(value("f64", 990000000000000), value("f64", 990000000000000)),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1251
+assert_return(
+  () => invoke($305, `f64-dec-sep5`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 12200011354000000000000000000),
+      value("f64", 12200011354000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1252
+assert_return(
+  () => invoke($305, `f64-hex-sep1`, []),
+  [new F64x2Pattern(value("f64", 168755353), value("f64", 168755353))],
+);
+
+// ./test/core/simd/simd_const.wast:1253
+assert_return(
+  () => invoke($305, `f64-hex-sep2`, []),
+  [new F64x2Pattern(value("f64", 109071), value("f64", 109071))],
+);
+
+// ./test/core/simd/simd_const.wast:1254
+assert_return(
+  () => invoke($305, `f64-hex-sep3`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 41215.94240794191),
+      value("f64", 41215.94240794191),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1255
+assert_return(
+  () => invoke($305, `f64-hex-sep4`, []),
+  [new F64x2Pattern(value("f64", 1966080), value("f64", 1966080))],
+);
+
+// ./test/core/simd/simd_const.wast:1256
+assert_return(
+  () => invoke($305, `f64-hex-sep5`, []),
+  [new F64x2Pattern(value("f64", 23605225168752), value("f64", 23605225168752))],
+);
+
+// ./test/core/simd/simd_const.wast:1258
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 _100 _100 _100 _100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1262
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1266
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1270
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 99_ 99_ 99_ 99_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1274
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1278
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1282
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1286
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1290
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1294
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1298
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1302
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1306
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1310
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1314
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1318
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1322
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1326
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1330
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1334
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1338
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1342
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1346
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1350
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1354
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1358
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1362
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1366
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1370
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1374
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1378
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1382
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1386
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1390
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1394
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1398
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1402
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1406
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1411
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 _100 _100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1415
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 +_100 +_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1419
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 -_100 -_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1423
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 99_ 99_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1427
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1__000 1__000)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1431
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 _1.0 _1.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1435
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1.0_ 1.0_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1439
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1_.0 1_.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1443
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1._0 1._0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1447
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 _1e1 _1e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1451
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1e1_ 1e1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1455
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1_e1 1_e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1459
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1e_1 1e_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1463
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 _1.0e1 _1.0e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1467
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1.0e1_ 1.0e1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1471
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1.0_e1 1.0_e1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1475
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1.0e_1 1.0e_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1479
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1483
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1487
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 _0x100 _0x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1491
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0_x100 0_x100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1495
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x_100 0x_100)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1499
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x00_ 0x00_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1503
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1507
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x_1.0 0x_1.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1511
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1.0_ 0x1.0_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1515
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1_.0 0x1_.0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1519
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1._0 0x1._0)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1523
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x_1p1 0x_1p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1527
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1p1_ 0x1p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1531
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1_p1 0x1_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1535
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1p_1 0x1p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1539
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1543
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1547
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1551
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1555
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1559
+assert_malformed(
+  () => instantiate(`(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1)) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_const.wast:1566
+let $306 = instantiate(`(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
+)`);
+
+// ./test/core/simd/simd_const.wast:1581
+assert_return(
+  () => invoke($306, `parse_i8x16`, []),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1583
+let $307 = instantiate(`(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
+)`);
+
+// ./test/core/simd/simd_const.wast:1598
+assert_return(
+  () => invoke($307, `parse_i16x8`, []),
+  [i16x8([0x0, 0x0, 0x8000, 0x8000, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_const.wast:1600
+let $308 = instantiate(`(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
+)`);
+
+// ./test/core/simd/simd_const.wast:1615
+assert_return(
+  () => invoke($308, `parse_i32x4`, []),
+  [i32x4([0xffffffd1, 0xffffffd1, 0xffffffd1, 0xffffffd1])],
+);
+
+// ./test/core/simd/simd_const.wast:1617
+let $309 = instantiate(`(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
+)`);
+
+// ./test/core/simd/simd_const.wast:1630
+assert_return(() => invoke($309, `parse_i64x2`, []), [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])]);
+
+// ./test/core/simd/simd_const.wast:1634
+let $310 = instantiate(`(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
+)`);
+
+// ./test/core/simd/simd_const.wast:1649
+assert_return(
+  () => invoke($310, `parse_f32x4`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 4294967300),
+      value("f32", 4294967300),
+      value("f32", 4294967300),
+      value("f32", 4294967300),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_const.wast:1651
+let $311 = instantiate(`(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
+)`);
+
+// ./test/core/simd/simd_const.wast:1664
+assert_return(
+  () => invoke($311, `parse_f64x2`, []),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js
new file mode 100644
index 0000000000..abb9d75af3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_conversions.wast.js
@@ -0,0 +1,3341 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_conversions.wast
+
+// ./test/core/simd/simd_conversions.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_conversions.wast:35
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [f32x4([0, 0, 0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_conversions.wast:37
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [f32x4([-0, -0, -0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_conversions.wast:39
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000001401298464324817),
+      value("f64", 0.000000000000000000000000000000000000000000001401298464324817),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:41
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000001401298464324817),
+      value("f64", -0.000000000000000000000000000000000000000000001401298464324817),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:43
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [f32x4([1, 1, 1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_conversions.wast:45
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [f32x4([-1, -1, -1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_conversions.wast:47
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -340282346638528860000000000000000000000),
+      value("f64", -340282346638528860000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:49
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 340282346638528860000000000000000000000),
+      value("f64", 340282346638528860000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:52
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([
+      0.0000000000000000000000000000000000015046328,
+      0.0000000000000000000000000000000000015046328,
+      0.0000000000000000000000000000000000015046328,
+      0.0000000000000000000000000000000000015046328,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000001504632769052528),
+      value("f64", 0.000000000000000000000000000000000001504632769052528),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:55
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([
+      66382537000000000000000000000000000000,
+      66382537000000000000000000000000000000,
+      66382537000000000000000000000000000000,
+      66382537000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 66382536710104395000000000000000000000),
+      value("f64", 66382536710104395000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:57
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_conversions.wast:59
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_conversions.wast:61
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_conversions.wast:63
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_conversions.wast:65
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_conversions.wast:67
+assert_return(
+  () => invoke($0, `f64x2.promote_low_f32x4`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_conversions.wast:73
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:75
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([-0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:77
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:79
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:81
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:83
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([-1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:85
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000011754942807573643,
+      0.000000000000000000000000000000000000011754942807573643,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:87
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000011754942807573643,
+      -0.000000000000000000000000000000000000011754942807573643,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:89
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000011754942807573642,
+      0.000000000000000000000000000000000000011754942807573642,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:91
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000011754942807573642,
+      -0.000000000000000000000000000000000000011754942807573642,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:93
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000001401298464324817,
+      0.000000000000000000000000000000000000000000001401298464324817,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:95
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000001401298464324817,
+      -0.000000000000000000000000000000000000000000001401298464324817,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:97
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      340282336497324060000000000000000000000,
+      340282336497324060000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282330000000000000000000000000000000),
+      value("f32", 340282330000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:99
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -340282336497324060000000000000000000000,
+      -340282336497324060000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282330000000000000000000000000000000),
+      value("f32", -340282330000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:101
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      340282336497324100000000000000000000000,
+      340282336497324100000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:103
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -340282336497324100000000000000000000000,
+      -340282336497324100000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:105
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      340282346638528860000000000000000000000,
+      340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:107
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -340282346638528860000000000000000000000,
+      -340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:109
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      340282356779733620000000000000000000000,
+      340282356779733620000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:111
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -340282356779733620000000000000000000000,
+      -340282356779733620000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:113
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      340282356779733660000000000000000000000,
+      340282356779733660000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:115
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -340282356779733660000000000000000000000,
+      -340282356779733660000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:117
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000001504632769052528,
+      0.000000000000000000000000000000000001504632769052528,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000000000000000000000000000000000015046328),
+      value("f32", 0.0000000000000000000000000000000000015046328),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:119
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([66382536710104395000000000000000000000, 66382536710104395000000000000000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 66382537000000000000000000000000000000),
+      value("f32", 66382537000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:121
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:123
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([-Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:125
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([1.0000000000000002, 1.0000000000000002]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:127
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([0.9999999999999999, 0.9999999999999999]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:129
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([1.0000000596046448, 1.0000000596046448]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:131
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([1.000000059604645, 1.000000059604645]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.0000001),
+      value("f32", 1.0000001),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:133
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([1.000000178813934, 1.000000178813934]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.0000001),
+      value("f32", 1.0000001),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:135
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([1.0000001788139343, 1.0000001788139343]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.0000002),
+      value("f32", 1.0000002),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:137
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([1.0000002980232239, 1.0000002980232239]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.0000002),
+      value("f32", 1.0000002),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:139
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([16777217, 16777217])]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777216),
+      value("f32", 16777216),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:141
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([16777217.000000004, 16777217.000000004]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777218),
+      value("f32", 16777218),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:143
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([16777218.999999996, 16777218.999999996]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777218),
+      value("f32", 16777218),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:145
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [f64x2([16777219, 16777219])]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777220),
+      value("f32", 16777220),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:147
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([424258443299142700000000000000000, 424258443299142700000000000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 424258450000000000000000000000000),
+      value("f32", 424258450000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:149
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.0000000000000000000000000000000001569262107843488,
+      0.0000000000000000000000000000000001569262107843488,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000015692621),
+      value("f32", 0.00000000000000000000000000000000015692621),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:151
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000010551773688605172,
+      0.000000000000000000000000000000000000010551773688605172,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000010551773),
+      value("f32", 0.000000000000000000000000000000000000010551773),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:153
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([-2.8238128484141933, -2.8238128484141933]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -2.823813),
+      value("f32", -2.823813),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:155
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([-9063376370095757000000000000000000, -9063376370095757000000000000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -9063376000000000000000000000000000),
+      value("f32", -9063376000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:157
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:159
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:161
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:163
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:165
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:167
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:169
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.0000000000000000000000000000000000000000000007006492321624085,
+      0.0000000000000000000000000000000000000000000007006492321624085,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:171
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.0000000000000000000000000000000000000000000007006492321624085,
+      -0.0000000000000000000000000000000000000000000007006492321624085,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:173
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      0.0000000000000000000000000000000000000000000007006492321624087,
+      0.0000000000000000000000000000000000000000000007006492321624087,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:175
+assert_return(
+  () => invoke($0, `f32x4.demote_f64x2_zero`, [
+    f64x2([
+      -0.0000000000000000000000000000000000000000000007006492321624087,
+      -0.0000000000000000000000000000000000000000000007006492321624087,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:182
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:184
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:186
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:188
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:190
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -2147483600),
+      value("f32", -2147483600),
+      value("f32", -2147483600),
+      value("f32", -2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:192
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234568000),
+      value("f32", 1234568000),
+      value("f32", 1234568000),
+      value("f32", 1234568000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:194
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x75bcd18, 0x75bcd18, 0x75bcd18, 0x75bcd18]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:196
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x12345680, 0x12345680, 0x12345680, 0x12345680]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 305419900),
+      value("f32", 305419900),
+      value("f32", 305419900),
+      value("f32", 305419900),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:200
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x1000001, 0x1000001, 0x1000001, 0x1000001]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777216),
+      value("f32", 16777216),
+      value("f32", 16777216),
+      value("f32", 16777216),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:202
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0xfeffffff, 0xfeffffff, 0xfeffffff, 0xfeffffff]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -16777216),
+      value("f32", -16777216),
+      value("f32", -16777216),
+      value("f32", -16777216),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:204
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x1000003, 0x1000003, 0x1000003, 0x1000003]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777220),
+      value("f32", 16777220),
+      value("f32", 16777220),
+      value("f32", 16777220),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:206
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0xfefffffd, 0xfefffffd, 0xfefffffd, 0xfefffffd]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -16777220),
+      value("f32", -16777220),
+      value("f32", -16777220),
+      value("f32", -16777220),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:208
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_s`, [
+    i32x4([0x0, 0xffffffff, 0x7fffffff, 0x80000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", -1),
+      value("f32", 2147483600),
+      value("f32", -2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:213
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:215
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:217
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 4294967300),
+      value("f32", 4294967300),
+      value("f32", 4294967300),
+      value("f32", 4294967300),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:219
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:221
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:223
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 305419900),
+      value("f32", 305419900),
+      value("f32", 305419900),
+      value("f32", 305419900),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:225
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x80000080, 0x80000080, 0x80000080, 0x80000080]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:227
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x80000081, 0x80000081, 0x80000081, 0x80000081]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2147484000),
+      value("f32", 2147484000),
+      value("f32", 2147484000),
+      value("f32", 2147484000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:229
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x80000082, 0x80000082, 0x80000082, 0x80000082]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2147484000),
+      value("f32", 2147484000),
+      value("f32", 2147484000),
+      value("f32", 2147484000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:231
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0xfffffe80, 0xfffffe80, 0xfffffe80, 0xfffffe80]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 4294966800),
+      value("f32", 4294966800),
+      value("f32", 4294966800),
+      value("f32", 4294966800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:233
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0xfffffe81, 0xfffffe81, 0xfffffe81, 0xfffffe81]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 4294967000),
+      value("f32", 4294967000),
+      value("f32", 4294967000),
+      value("f32", 4294967000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:235
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0xfffffe82, 0xfffffe82, 0xfffffe82, 0xfffffe82]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 4294967000),
+      value("f32", 4294967000),
+      value("f32", 4294967000),
+      value("f32", 4294967000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:237
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x75bcd18, 0x75bcd18, 0x75bcd18, 0x75bcd18]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:239
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2427178500),
+      value("f32", 2427178500),
+      value("f32", 2427178500),
+      value("f32", 2427178500),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:243
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x1000001, 0x1000001, 0x1000001, 0x1000001]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777216),
+      value("f32", 16777216),
+      value("f32", 16777216),
+      value("f32", 16777216),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:245
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x1000003, 0x1000003, 0x1000003, 0x1000003]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 16777220),
+      value("f32", 16777220),
+      value("f32", 16777220),
+      value("f32", 16777220),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:247
+assert_return(
+  () => invoke($0, `f32x4.convert_i32x4_u`, [
+    i32x4([0x0, 0xffffffff, 0x7fffffff, 0x80000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 4294967300),
+      value("f32", 2147483600),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:253
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_s`, [i32x4([0x1, 0x1, 0x0, 0x0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_conversions.wast:255
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_conversions.wast:257
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_s`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_conversions.wast:259
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", 2147483647), value("f64", 2147483647))],
+);
+
+// ./test/core/simd/simd_conversions.wast:261
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", -2147483648), value("f64", -2147483648))],
+);
+
+// ./test/core/simd/simd_conversions.wast:263
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_s`, [
+    i32x4([0x3ade68b1, 0x3ade68b1, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", 987654321), value("f64", 987654321))],
+);
+
+// ./test/core/simd/simd_conversions.wast:269
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_u`, [i32x4([0x1, 0x1, 0x0, 0x0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_conversions.wast:271
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_u`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_conversions.wast:273
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", 2147483647), value("f64", 2147483647))],
+);
+
+// ./test/core/simd/simd_conversions.wast:275
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", 2147483648), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_conversions.wast:277
+assert_return(
+  () => invoke($0, `f64x2.convert_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [new F64x2Pattern(value("f64", 4294967295), value("f64", 4294967295))],
+);
+
+// ./test/core/simd/simd_conversions.wast:283
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:286
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:289
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:292
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:295
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:298
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:301
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:304
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:307
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:310
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:313
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:316
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:319
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:322
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:325
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:328
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81]),
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:331
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+    i16x8([0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:334
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:337
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f]),
+    i16x8([0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:340
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f]),
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:343
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+    i16x8([0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:346
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:349
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:352
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:355
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:358
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f, 0xff7f]),
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:361
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:364
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:367
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:372
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:375
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:378
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:381
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:384
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:387
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:390
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:393
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:396
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:399
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:402
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:405
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:408
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:411
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:414
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:417
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:420
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:423
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:426
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:429
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:432
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:435
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:438
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:441
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:444
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:447
+assert_return(
+  () => invoke($0, `i8x16.narrow_i16x8_u`, [
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:452
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:455
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_conversions.wast:458
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:461
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:464
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:467
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:470
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_conversions.wast:473
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:476
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_conversions.wast:479
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:482
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:485
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:488
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:491
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:494
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:497
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8001, 0xffff8001, 0xffff8001, 0xffff8001]),
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_conversions.wast:500
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+    i32x4([0xffff8001, 0xffff8001, 0xffff8001, 0xffff8001]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_conversions.wast:503
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_conversions.wast:506
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff7fff, 0xffff7fff, 0xffff7fff, 0xffff7fff]),
+    i32x4([0xffff7fff, 0xffff7fff, 0xffff7fff, 0xffff7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_conversions.wast:509
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff7fff, 0xffff7fff, 0xffff7fff, 0xffff7fff]),
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_conversions.wast:512
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+    i32x4([0xffff7fff, 0xffff7fff, 0xffff7fff, 0xffff7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_conversions.wast:515
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:518
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:521
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff7fff, 0xffff7fff, 0xffff7fff, 0xffff7fff]),
+    i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:524
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:527
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xffff7fff, 0xffff7fff, 0xffff7fff, 0xffff7fff]),
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:530
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0xf8000000, 0xf8000000, 0xf8000000, 0xf8000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:533
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:536
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_s`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:541
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:544
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_conversions.wast:547
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:550
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:553
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:556
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:559
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_conversions.wast:562
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xfffe, 0xfffe, 0xfffe, 0xfffe]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:565
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xfffe, 0xfffe, 0xfffe, 0xfffe]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_conversions.wast:568
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:571
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:574
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:577
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:580
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:583
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:586
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:589
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x10000, 0x10000, 0x10000, 0x10000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:592
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:595
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:598
+assert_return(
+  () => invoke($0, `i16x8.narrow_i32x4_u`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:605
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.trunc_sat_f32x4 (v128.const f32x4 0.0 0.0 0.0 0.0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:608
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.trunc_s_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:611
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.trunc_u_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:614
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.convert_f32x4 (v128.const f32x4 -1 0 1 2))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:617
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.convert_s_f32x4 (v128.const f32x4 -1 0 1 2))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:620
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.convert_u_f32x4 (v128.const f32x4 -1 0 1 2))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:624
+assert_malformed(
+  () => instantiate(`(func (result v128) (i64x2.trunc_sat_f64x2_s (v128.const f64x2 0.0 0.0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:627
+assert_malformed(
+  () => instantiate(`(func (result v128) (i64x2.trunc_sat_f64x2_u (v128.const f64x2 -2.0 -1.0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:630
+assert_malformed(
+  () => instantiate(`(func (result v128) (f64x2.convert_i64x2_s (v128.const i64x2 1 2))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:633
+assert_malformed(
+  () => instantiate(`(func (result v128) (f64x2.convert_i64x2_u (v128.const i64x2 1 2))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:637
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:640
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:643
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:646
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:649
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:652
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:655
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:658
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:662
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:665
+assert_malformed(
+  () => instantiate(`(func (result v128) (i8x16.extend_low_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:668
+assert_malformed(
+  () => instantiate(`(func (result v128) (i8x16.extend_low_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:671
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:674
+assert_malformed(
+  () => instantiate(`(func (result v128) (i8x16.extend_high_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:677
+assert_malformed(
+  () => instantiate(`(func (result v128) (i8x16.extend_high_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:680
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.extend_low_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:683
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.extend_low_i32x4_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:686
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.extend_low_i32x4_u (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:689
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.extend_high_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:692
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.extend_high_i32x4_s (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:695
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.extend_high_i32x4_u (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_conversions.wast:702
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.convert_i32x4_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:703
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.convert_i32x4_s (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:704
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.convert_i32x4_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:705
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.convert_i32x4_u (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:707
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.narrow_i16x8_s (i32.const 0) (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:708
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.narrow_i16x8_u (i32.const 0) (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:709
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:710
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:715
+let $1 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_conversions.wast:758
+assert_return(
+  () => invoke($1, `f32x4_convert_i32x4_s_add`, [
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+    i32x4([0x2, 0x3, 0x4, 0x5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3),
+      value("f32", 5),
+      value("f32", 7),
+      value("f32", 9),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:761
+assert_return(
+  () => invoke($1, `f32x4_convert_i32x4_s_sub`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:764
+assert_return(
+  () => invoke($1, `f32x4_convert_i32x4_u_mul`, [
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+    i32x4([0x1, 0x2, 0x3, 0x4]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 4),
+      value("f32", 9),
+      value("f32", 16),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_conversions.wast:768
+assert_return(
+  () => invoke($1, `i16x8_low_extend_narrow_ss`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0x7f, 0xff80, 0xff80, 0xff80, 0x7f, 0xff80])],
+);
+
+// ./test/core/simd/simd_conversions.wast:771
+assert_return(
+  () => invoke($1, `i16x8_low_extend_narrow_su`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0xffff, 0x8000, 0x8001, 0x7fff, 0xffff]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0xffff, 0x8000, 0x8001, 0x7fff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0x0, 0x0, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:774
+assert_return(
+  () => invoke($1, `i16x8_high_extend_narrow_ss`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0x7f, 0xff80, 0xff80, 0xff80, 0x7f, 0xff80])],
+);
+
+// ./test/core/simd/simd_conversions.wast:777
+assert_return(
+  () => invoke($1, `i16x8_high_extend_narrow_su`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0xffff, 0x8000, 0x8001, 0x7fff, 0xffff]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0xffff, 0x8000, 0x8001, 0x7fff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0x0, 0x0, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:780
+assert_return(
+  () => invoke($1, `i16x8_low_extend_narrow_uu`, [
+    i16x8([0x8000, 0x8001, 0x8000, 0xffff, 0x8000, 0x8001, 0x8000, 0xffff]),
+    i16x8([0x8000, 0x8001, 0x8000, 0xffff, 0x8000, 0x8001, 0x8000, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:783
+assert_return(
+  () => invoke($1, `i16x8_low_extend_narrow_us`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+  ]),
+  [i16x8([0x80, 0x80, 0x7f, 0x80, 0x80, 0x80, 0x7f, 0x80])],
+);
+
+// ./test/core/simd/simd_conversions.wast:786
+assert_return(
+  () => invoke($1, `i16x8_high_extend_narrow_uu`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0xffff, 0x8000, 0x8001, 0x7fff, 0xffff]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0xffff, 0x8000, 0x8001, 0x7fff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:789
+assert_return(
+  () => invoke($1, `i16x8_high_extend_narrow_us`, [
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+    i16x8([0x8000, 0x8001, 0x7fff, 0x8000, 0x8000, 0x8001, 0x7fff, 0x8000]),
+  ]),
+  [i16x8([0x80, 0x80, 0x7f, 0x80, 0x80, 0x80, 0x7f, 0x80])],
+);
+
+// ./test/core/simd/simd_conversions.wast:793
+assert_return(
+  () => invoke($1, `i32x4_low_extend_narrow_ss`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:796
+assert_return(
+  () => invoke($1, `i32x4_low_extend_narrow_su`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:799
+assert_return(
+  () => invoke($1, `i32x4_high_extend_narrow_ss`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:802
+assert_return(
+  () => invoke($1, `i32x4_high_extend_narrow_su`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:805
+assert_return(
+  () => invoke($1, `i32x4_low_extend_narrow_uu`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:808
+assert_return(
+  () => invoke($1, `i32x4_low_extend_narrow_us`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:811
+assert_return(
+  () => invoke($1, `i32x4_high_extend_narrow_uu`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_conversions.wast:814
+assert_return(
+  () => invoke($1, `i32x4_high_extend_narrow_us`, [
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+    i32x4([0x80000000, 0x80000001, 0x7fffffff, 0x8000000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_conversions.wast:820
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.convert_i32x4_s-arg-empty (result v128)
+      (f32x4.convert_i32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:828
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.convert_i32x4_u-arg-empty (result v128)
+      (f32x4.convert_i32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:836
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:844
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.narrow_i16x8_s-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:852
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_conversions.wast:860
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.narrow_i16x8_u-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:868
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.narrow_i32x4_s-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:876
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.narrow_i32x4_s-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:884
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.narrow_i32x4_u-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_conversions.wast:892
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.narrow_i32x4_u-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js
new file mode 100644
index 0000000000..c3d30b4669
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4.wast.js
@@ -0,0 +1,18269 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f32x4.wast
+
+// ./test/core/simd/simd_f32x4.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4.wast:33
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_0`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", -3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:34
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_1`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:35
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_2`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:36
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_3`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:38
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_5`, [f32x4([0, 2, 1, 3])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", -3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:40
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_6`, [f32x4([0, 1, 2, 3])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:42
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_7`, [f32x4([0, 2, 1, 2147483600])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:44
+assert_return(
+  () => invoke($0, `f32x4.min_with_const_8`, [f32x4([0, 1, 2, 2147483600])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:47
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_10`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:48
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_11`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:49
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_12`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:50
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_13`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:52
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_15`, [f32x4([0, 2, 1, 3])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:54
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_16`, [f32x4([0, 1, 2, 3])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:56
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_17`, [f32x4([0, 2, 1, 2147483600])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:58
+assert_return(
+  () => invoke($0, `f32x4.max_with_const_18`, [f32x4([0, 1, 2, 2147483600])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 2147483600),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:61
+assert_return(
+  () => invoke($0, `f32x4.abs_with_const`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:65
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:73
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:81
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:89
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 1),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:97
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:100
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:103
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:106
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:109
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:112
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:115
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:118
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:121
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:124
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:127
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:130
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:133
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:136
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:139
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:142
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:145
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:148
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:151
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:154
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:157
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:160
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:163
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:166
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:169
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:172
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:175
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:178
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:181
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:184
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:187
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:190
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:193
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:196
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:199
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:202
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:205
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:208
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:211
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:214
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:217
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:220
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:223
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:226
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:229
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:232
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:235
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:238
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:241
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:244
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:247
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:250
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:253
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:256
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:259
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:262
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:265
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:268
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:271
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:274
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:277
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:280
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:283
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:286
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:289
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:292
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:295
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:298
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:301
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:304
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:307
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:310
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:313
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:316
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:319
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:322
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:325
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:328
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:331
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:334
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:337
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:340
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:343
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:346
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:349
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:352
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:355
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:358
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:361
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:364
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:367
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:370
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:373
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:376
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:379
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:382
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:385
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:388
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:391
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:394
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:397
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:400
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:403
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:406
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:409
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:412
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:415
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:418
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:421
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:424
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:427
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:430
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:433
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:436
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:439
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:442
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:445
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:448
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:451
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:454
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:457
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:460
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:463
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:466
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:469
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:472
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:475
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:478
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:481
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:484
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:487
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:490
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:493
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:496
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:499
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:502
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:505
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:508
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:511
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:514
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:517
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:520
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:523
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:526
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:529
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:532
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:535
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:538
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:541
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:544
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:547
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:550
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:553
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:556
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:559
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:562
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:565
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:568
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:571
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:574
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:577
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:580
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:583
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:586
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:589
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:592
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:595
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:598
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:601
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:604
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:607
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:610
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:613
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:616
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:619
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:622
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:625
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:628
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:631
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:634
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:637
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:640
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:643
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:646
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:649
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:652
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:655
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:658
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:661
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:664
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:667
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:670
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:673
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:676
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:679
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:682
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:685
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:688
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:691
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:694
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:697
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:700
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:703
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:706
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:709
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:712
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:715
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:718
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:721
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:724
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:727
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:730
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:733
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:736
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:739
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:742
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:745
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:748
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:751
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:754
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:757
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:760
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:763
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:766
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:769
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:772
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:775
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:778
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:781
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:784
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:787
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:790
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:793
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:796
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:799
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:802
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:805
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:808
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:811
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:814
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:817
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:820
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:823
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:826
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:829
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:832
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:835
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:838
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:841
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:844
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:847
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:850
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:853
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:856
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:859
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:862
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:865
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:868
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:871
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:874
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:877
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:880
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:883
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:886
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:889
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:892
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:895
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:898
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:901
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:904
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:907
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:910
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:913
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:916
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:919
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:922
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:925
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:928
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:931
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:934
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:937
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:940
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:943
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:946
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:949
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:952
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:955
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:958
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:961
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:964
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:967
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:970
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:973
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:976
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:979
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:982
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:985
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:988
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:991
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:994
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:997
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1000
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1003
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1006
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1009
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1012
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1015
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1018
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1021
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1024
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1027
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1030
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1033
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1036
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1039
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1042
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1045
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1048
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1051
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1054
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1057
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1060
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1063
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1066
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1069
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1072
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1075
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1078
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1081
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1084
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1087
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1090
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1093
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1096
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1099
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1102
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1105
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1108
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1111
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1114
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1117
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1120
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1123
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1126
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1129
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1132
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1135
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1138
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1141
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1144
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1147
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1150
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1153
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1156
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1159
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1162
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1165
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1168
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1171
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1174
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1177
+assert_return(
+  () => invoke($0, `f32x4.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1180
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1183
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1186
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1189
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1192
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1195
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1198
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1201
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1204
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1207
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1210
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1213
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1216
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1219
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1222
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1225
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1228
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1231
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1234
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1237
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1240
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1243
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1246
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1249
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1252
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1255
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1258
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1261
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1264
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1267
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1270
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1273
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1276
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1279
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1282
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1285
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1288
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1291
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1294
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1297
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1300
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1303
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1306
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1309
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1312
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1315
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1318
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1321
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1324
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1327
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1330
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1333
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1336
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1339
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1342
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1345
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1348
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1351
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1354
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1357
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1360
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1363
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1366
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1369
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1372
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1375
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1378
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1381
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1384
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1387
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1390
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1393
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1396
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1399
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1402
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1405
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1408
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1411
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1414
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1417
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1420
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1423
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1426
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1429
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1432
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1435
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1438
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1441
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1444
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1447
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1450
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1453
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1456
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1459
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1462
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1465
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1468
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1471
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1474
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1477
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1480
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1483
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1486
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1489
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1492
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1495
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1498
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1501
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1504
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1507
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1510
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1513
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1516
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1519
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1522
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1525
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1528
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1531
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1534
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1537
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1540
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1543
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1546
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1549
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1552
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1555
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1558
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1561
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1564
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1567
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1570
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1573
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1576
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1579
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1582
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1585
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1588
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1591
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1594
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1597
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1600
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1603
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1606
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1609
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1612
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1615
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1618
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1621
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1624
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1627
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1630
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1633
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1636
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1639
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1642
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1645
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1648
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1651
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1654
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1657
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1660
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1663
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1666
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1669
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1672
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1675
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1678
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1681
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1684
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1687
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1690
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1693
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1696
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1699
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1702
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1705
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1708
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1711
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1714
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1717
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1720
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1723
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1726
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1729
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1732
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1735
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1738
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1741
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1744
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1747
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1750
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1753
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1756
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1759
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1762
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1765
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1768
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1771
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1774
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1777
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1780
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1783
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1786
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1789
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1792
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1795
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1798
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1801
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1804
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1807
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1810
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1813
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1816
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1819
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1822
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1825
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1828
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1831
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1834
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1837
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1840
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1843
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1846
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1849
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1852
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1855
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1858
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1861
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1864
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1867
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1870
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1873
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1876
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1879
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1882
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1885
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1888
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1891
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1894
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1897
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1900
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1903
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1906
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1909
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1912
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1915
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1918
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1921
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1924
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1927
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1930
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1933
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1936
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1939
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1942
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1945
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1948
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1951
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1954
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1957
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1960
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1963
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1966
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1969
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1972
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1975
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1978
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1981
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1984
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1987
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1990
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1993
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1996
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:1999
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2002
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2005
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2008
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2011
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2014
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2017
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2020
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2023
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2026
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2029
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2032
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2035
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2038
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2041
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2044
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2047
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2050
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2053
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2056
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2059
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2062
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2065
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2068
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2071
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2074
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2077
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2080
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2083
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2086
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2089
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2092
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2095
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2098
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2101
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2104
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2107
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2110
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2113
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2116
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2119
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2122
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2125
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2128
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2131
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2134
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2137
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2140
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2143
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2146
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2149
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2152
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2155
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2158
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2161
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2164
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2167
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2170
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2173
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2176
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2179
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2182
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2185
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2188
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2191
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2194
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2197
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2200
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2203
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2206
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2209
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2212
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2215
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2218
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2221
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2224
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2227
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2230
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2233
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2236
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2239
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2242
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2245
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2248
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2251
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2254
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2257
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2260
+assert_return(
+  () => invoke($0, `f32x4.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2265
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([0, 0, -0, 0]), f32x4([0, -0, 0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2268
+assert_return(
+  () => invoke($0, `f32x4.min`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2271
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([0, 0, -0, 0]), f32x4([0, -0, 0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2274
+assert_return(
+  () => invoke($0, `f32x4.max`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2279
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2281
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2283
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2285
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2287
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2289
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2291
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2293
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2295
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2297
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2299
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855])]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2301
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2303
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2305
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2307
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2309
+assert_return(
+  () => invoke($0, `f32x4.abs`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2311
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2313
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2315
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2317
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2319
+assert_return(
+  () => invoke($0, `f32x4.abs`, [
+    f32x4([-123456790, -123456790, -123456790, -123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2325
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2326
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2327
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2328
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2329
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2330
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2331
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2332
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2335
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.abs (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2336
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2337
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2341
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.abs-arg-empty (result v128)
+      (f32x4.abs)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2349
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.min-1st-arg-empty (result v128)
+      (f32x4.min (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2357
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.min-arg-empty (result v128)
+      (f32x4.min)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2365
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.max-1st-arg-empty (result v128)
+      (f32x4.max (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2373
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.max-arg-empty (result v128)
+      (f32x4.max)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4.wast:2383
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4.wast:2394
+assert_return(
+  () => invoke($1, `max-min`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2398
+assert_return(
+  () => invoke($1, `min-max`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.125),
+      value("f32", 0.125),
+      value("f32", 0.125),
+      value("f32", 0.125),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2402
+assert_return(
+  () => invoke($1, `max-abs`, [
+    f32x4([-1.125, -1.125, -1.125, -1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.125),
+      value("f32", 1.125),
+      value("f32", 1.125),
+      value("f32", 1.125),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4.wast:2405
+assert_return(
+  () => invoke($1, `min-abs`, [
+    f32x4([-1.125, -1.125, -1.125, -1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.125),
+      value("f32", 0.125),
+      value("f32", 0.125),
+      value("f32", 0.125),
+    ),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js
new file mode 100644
index 0000000000..44410bfa92
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_arith.wast.js
@@ -0,0 +1,45212 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f32x4_arith.wast
+
+// ./test/core/simd/simd_f32x4_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4_arith.wast:13
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:16
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:19
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:22
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:25
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:28
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:31
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:34
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:37
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:40
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:43
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:46
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:49
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:52
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:55
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:58
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:61
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:64
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:67
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:70
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:73
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:76
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:79
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:82
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:85
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:88
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:91
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:94
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:97
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:100
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:103
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:106
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:109
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:112
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:115
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:118
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:121
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:124
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:127
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:130
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:133
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:136
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:139
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:142
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:145
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:148
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:151
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:154
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:157
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:160
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:163
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:166
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:169
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:172
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:175
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:178
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:181
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:184
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:187
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:190
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:193
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:196
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:199
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:202
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:205
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:208
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:211
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:214
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:217
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:220
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:223
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:226
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:229
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:232
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:235
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:238
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:241
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:244
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:247
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:250
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:253
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:256
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:259
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:262
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:265
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:268
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:271
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:274
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:277
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:280
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:283
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:286
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:289
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:292
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:295
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:298
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:301
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:304
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:307
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:310
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:313
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:316
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:319
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:322
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:325
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:328
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:331
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:334
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:337
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:340
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:343
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:346
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:349
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:352
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:355
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:358
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:361
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:364
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:367
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:370
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:373
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:376
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:379
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:382
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:385
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:388
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:391
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:394
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:397
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:400
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:403
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:406
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:409
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:412
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:415
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:418
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:421
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:424
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:427
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:430
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:433
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:436
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:439
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:442
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:445
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:448
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:451
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:454
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:457
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:460
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:463
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:466
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:469
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:472
+assert_return(
+  () => invoke($0, `f32x4.add`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:475
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:478
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:481
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:484
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:487
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:490
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:493
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:496
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:499
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:502
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:505
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:508
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:511
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:514
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:517
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:520
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:523
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:526
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:529
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:532
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:535
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:538
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:541
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:544
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:547
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:550
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:553
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:556
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:559
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:562
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:565
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:568
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:571
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:574
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:577
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:580
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:583
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:586
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:589
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:592
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:595
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:598
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:601
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:604
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:607
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:610
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:613
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:616
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:619
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:622
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:625
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:628
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:631
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:634
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:637
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:640
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:643
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:646
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:649
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:652
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:655
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:658
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:661
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:664
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:667
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:670
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:673
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:676
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:679
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:682
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:685
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:688
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:691
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:694
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:697
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:700
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:703
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:706
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:709
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:712
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:715
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:718
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:721
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:724
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:727
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:730
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:733
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:736
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:739
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:742
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:745
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:748
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:751
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:754
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:757
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:760
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:763
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:766
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:769
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:772
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:775
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:778
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:781
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:784
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:787
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:790
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:793
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:796
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:799
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:802
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:805
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:808
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:811
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:814
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:817
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:820
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:823
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:826
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:829
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:832
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:835
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:838
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:841
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:844
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:847
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:850
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:853
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:856
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:859
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:862
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:865
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:868
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:871
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:874
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:877
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:880
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:883
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:886
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:889
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:892
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:895
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:898
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:901
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:904
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:907
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:910
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:913
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:916
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:919
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:922
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:925
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:928
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:931
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:934
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:937
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:940
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:943
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:946
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:949
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:952
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:955
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:958
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:961
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:964
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:967
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:970
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:973
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:976
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:979
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:982
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:985
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:988
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:991
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:994
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:997
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1000
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1003
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1006
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1009
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1012
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1015
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1018
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1021
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1024
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1027
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1030
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1033
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1036
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1039
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1042
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1045
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1048
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1051
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1054
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1057
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1060
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1063
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1066
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1069
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1072
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1075
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1078
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1081
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1084
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1087
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1090
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1093
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1096
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1099
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1102
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1105
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1108
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1111
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1114
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1117
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1120
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1123
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1126
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1129
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1132
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1135
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1138
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1141
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1144
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1147
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1150
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1153
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1156
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1159
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1162
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1165
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1168
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1171
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1174
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1177
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1180
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1183
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1186
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1189
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1192
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1195
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1198
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1201
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1204
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1207
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1210
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1213
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 246913580),
+      value("f32", 246913580),
+      value("f32", 246913580),
+      value("f32", 246913580),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1216
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1219
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1222
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1225
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 246913580),
+      value("f32", 246913580),
+      value("f32", 246913580),
+      value("f32", 246913580),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1228
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1231
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1234
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1237
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 246913580),
+      value("f32", 246913580),
+      value("f32", 246913580),
+      value("f32", 246913580),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1240
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1243
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+      value("f32", 2469135800000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1246
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+      value("f32", 0.000000000024691358),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1249
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1252
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1255
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1258
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1261
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1264
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1267
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1270
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1273
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+      value("f32", 163971060000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1276
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1279
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+      value("f32", 85968060000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1282
+assert_return(
+  () => invoke($0, `f32x4.add`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+      value("f32", 312749980000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1285
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1288
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1291
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1294
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1297
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1300
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1303
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1306
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1309
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1312
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1315
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1318
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1321
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1324
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1327
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1330
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1333
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1336
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1339
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1342
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1345
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1348
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1351
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1354
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1357
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1360
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1363
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1366
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1369
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1372
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1375
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1378
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1381
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1384
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1387
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1390
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1393
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1396
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1399
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1402
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1405
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1408
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1411
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1414
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1417
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1420
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1423
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1426
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1429
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1432
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1435
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1438
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1441
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1444
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1447
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1450
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1453
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1456
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1459
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1462
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1465
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1468
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1471
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1474
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1477
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1480
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1483
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+      value("f32", 0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1486
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+      value("f32", 0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1489
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1492
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1495
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1498
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1501
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1504
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1507
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1510
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1513
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1516
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1519
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1522
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1525
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1528
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1531
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+      value("f32", -0.000000000000000000000000000000000000011754945),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1534
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+      value("f32", -0.000000000000000000000000000000000000011754942),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1537
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1540
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1543
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1546
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1549
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1552
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1555
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1558
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1561
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1564
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1567
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1570
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1573
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1576
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1579
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1582
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1585
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1588
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1591
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1594
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1597
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1600
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1603
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1606
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1609
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1612
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1615
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1618
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1621
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1624
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1627
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1630
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1633
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1636
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1639
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1642
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1645
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1648
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1651
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1654
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1657
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1660
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1663
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1666
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1669
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1672
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1675
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1678
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1681
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1684
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1687
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1690
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+      value("f32", 1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1693
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1696
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1699
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1702
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1705
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1708
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1711
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1714
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1717
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1720
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1723
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1726
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1729
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1732
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1735
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+      value("f32", -1.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1738
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1741
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1744
+assert_return(
+  () => invoke($0, `f32x4.sub`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1747
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1750
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1753
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1756
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1759
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1762
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1765
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1768
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1771
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1774
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1777
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1780
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1783
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+      value("f32", 5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1786
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+      value("f32", 6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1789
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+      value("f32", 5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1792
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+      value("f32", 7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1795
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1798
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1801
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1804
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1807
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1810
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1813
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1816
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1819
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1822
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1825
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1828
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1831
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+      value("f32", -6.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1834
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+      value("f32", -5.7831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1837
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+      value("f32", -7.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1840
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+      value("f32", -5.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1843
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1846
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1849
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1852
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1855
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1858
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1861
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1864
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1867
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1870
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1873
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1876
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1879
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1882
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1885
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1888
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1891
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1894
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1897
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1900
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1903
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1906
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1909
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1912
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1915
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1918
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1921
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1924
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1927
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1930
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1933
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1936
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1939
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1942
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1945
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1948
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1951
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1954
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1957
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1960
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1963
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1966
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1969
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1972
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1975
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1978
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1981
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1984
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1987
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1990
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1993
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1996
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:1999
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2002
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2005
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2008
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2011
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2014
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2017
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2020
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2023
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2026
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2029
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2032
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2035
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2038
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2041
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2044
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2047
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2050
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2053
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2056
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2059
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2062
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2065
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2068
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2071
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2074
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2077
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2080
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2083
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2086
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2089
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2092
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2095
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2098
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2101
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2104
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2107
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2110
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2113
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2116
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2119
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2122
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2125
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2128
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2131
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2134
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2137
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2140
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2143
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2146
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2149
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2152
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2155
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2158
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2161
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2164
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2167
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2170
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2173
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2176
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2179
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2182
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2185
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2188
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2191
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2194
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2197
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2200
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2203
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2206
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2209
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2212
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2215
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2218
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2221
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2224
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2227
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2230
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2233
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2236
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2239
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2242
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2245
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2248
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2251
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2254
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2257
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2260
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2263
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2266
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2269
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2272
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2275
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2278
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2281
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2284
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2287
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2290
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2293
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2296
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2299
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2302
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2305
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2308
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2311
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2314
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2317
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2320
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2323
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2326
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2329
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2332
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2335
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2338
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2341
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2344
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2347
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2350
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2353
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2356
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2359
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2362
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2365
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2368
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2371
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2374
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2377
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2380
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2383
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2386
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2389
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2392
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2395
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2398
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2401
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2404
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2407
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2410
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2413
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2416
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2419
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2422
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2425
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2428
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2431
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2434
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2437
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2440
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2443
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2446
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2449
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2452
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2455
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2458
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2461
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2464
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2467
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2470
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2473
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2476
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2479
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2482
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2485
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2488
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2491
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2494
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2497
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2500
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2503
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2506
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2509
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2512
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2515
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2518
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2521
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2524
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2527
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2530
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2533
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2536
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2539
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2542
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2545
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2548
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2551
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2554
+assert_return(
+  () => invoke($0, `f32x4.sub`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2557
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2560
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2563
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2566
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2569
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2572
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2575
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2578
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2581
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2584
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2587
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2590
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2593
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2596
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2599
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2602
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2605
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2608
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2611
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2614
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2617
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2620
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2623
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2626
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2629
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2632
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2635
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2638
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2641
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2644
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2647
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2650
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2653
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2656
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2659
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2662
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2665
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2668
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2671
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2674
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2677
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2680
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2683
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2686
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2689
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2692
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2695
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2698
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2701
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2704
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2707
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2710
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2713
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2716
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2719
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2722
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2725
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2728
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2731
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2734
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2737
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2740
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2743
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2746
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2749
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2752
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2755
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2758
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2761
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2764
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2767
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2770
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2773
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2776
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2779
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2782
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2785
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2788
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2791
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2794
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2797
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2800
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2803
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2806
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2809
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2812
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2815
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2818
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2821
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2824
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2827
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2830
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2833
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2836
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2839
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2842
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2845
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2848
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2851
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2854
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2857
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2860
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2863
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2866
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.25),
+      value("f32", -0.25),
+      value("f32", -0.25),
+      value("f32", -0.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2869
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2872
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2875
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2878
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2881
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2884
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2887
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2890
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2893
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2896
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2899
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2902
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2905
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+      value("f32", -0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2908
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+      value("f32", 0.000000000000000000000000000000000000005877472),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2911
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.25),
+      value("f32", -0.25),
+      value("f32", -0.25),
+      value("f32", -0.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2914
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2917
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2920
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2923
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2926
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2929
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2932
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2935
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2938
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2941
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2944
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2947
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2950
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2953
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2956
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2959
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2962
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2965
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2968
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2971
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2974
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2977
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2980
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2983
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2986
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2989
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2992
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2995
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:2998
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3001
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3004
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3007
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3010
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3013
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3016
+assert_return(
+  () => invoke($0, `f32x4.mul`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3019
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3022
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3025
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3028
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3031
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3034
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3037
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3040
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3043
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3046
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3049
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3052
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3055
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3058
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3061
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3064
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3067
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 39.47842),
+      value("f32", 39.47842),
+      value("f32", 39.47842),
+      value("f32", 39.47842),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3070
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -39.47842),
+      value("f32", -39.47842),
+      value("f32", -39.47842),
+      value("f32", -39.47842),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3073
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3076
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3079
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3082
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3085
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3088
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3091
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+      value("f32", -0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3094
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+      value("f32", 0.000000000000000000000000000000000000000000008),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3097
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+      value("f32", -0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3100
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+      value("f32", 0.00000000000000000000000000000000000007385849),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3103
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+      value("f32", -3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3106
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+      value("f32", 3.1415927),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3109
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3112
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3115
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -39.47842),
+      value("f32", -39.47842),
+      value("f32", -39.47842),
+      value("f32", -39.47842),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3118
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 39.47842),
+      value("f32", 39.47842),
+      value("f32", 39.47842),
+      value("f32", 39.47842),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3121
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3124
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3127
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3130
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3133
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3136
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3139
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3142
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3145
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3148
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3151
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3154
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3157
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3160
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3163
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3166
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3169
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3172
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3175
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3178
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3181
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3184
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3187
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+      value("f32", -0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3190
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+      value("f32", 0.00000047683713),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3193
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+      value("f32", -3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3196
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+      value("f32", 3.9999998),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3199
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+      value("f32", -170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3202
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+      value("f32", 170141170000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3205
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3208
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3211
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3214
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3217
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3220
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3223
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3226
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3229
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3232
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3235
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3238
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3241
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3244
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3247
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3250
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3253
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3256
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3259
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3262
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3265
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3268
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3271
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3274
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3277
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3280
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3283
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3286
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3289
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3292
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3295
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3298
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3301
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3304
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3307
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3310
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3313
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3316
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3319
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3322
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3325
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3328
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3331
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3334
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3337
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3340
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3343
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3346
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3349
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3352
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3355
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3358
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3361
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3364
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3367
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3370
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3373
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3376
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3379
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3382
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3385
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3388
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3391
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3394
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3397
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3400
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3403
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3406
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3409
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3412
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3415
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3418
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3421
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3424
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3427
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3430
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3433
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3436
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3439
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3442
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3445
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3448
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3451
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3454
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3457
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3460
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3463
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3466
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3469
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3472
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3475
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3478
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3481
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3484
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3487
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3490
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3493
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3496
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3499
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3502
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3505
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3508
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3511
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3514
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3517
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3520
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3523
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3526
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3529
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3532
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3535
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3538
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3541
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3544
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3547
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3550
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3553
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3556
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3559
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3562
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3565
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3568
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3571
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3574
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3577
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3580
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3583
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3586
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3589
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3592
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3595
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3598
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3601
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3604
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3607
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3610
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3613
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3616
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3619
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3622
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3625
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3628
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3631
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3634
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3637
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3640
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3643
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3646
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3649
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3652
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3655
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3658
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3661
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3664
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3667
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3670
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3673
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3676
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3679
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3682
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3685
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3688
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3691
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3694
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3697
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3700
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3703
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3706
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3709
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3712
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3715
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3718
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3721
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3724
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3727
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3730
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3733
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3736
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3739
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3742
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3745
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3748
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3751
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3754
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3757
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3760
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3763
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3766
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3769
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3772
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3775
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3778
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3781
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+      value("f32", 15241579000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3784
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3787
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3790
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+      value("f32", 0.00000000000000000000015241579),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3793
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3796
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3799
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3802
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3805
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3808
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3811
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3814
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3817
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+      value("f32", 6721627600000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3820
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3823
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3826
+assert_return(
+  () => invoke($0, `f32x4.mul`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+      value("f32", 24453139000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3829
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3832
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3835
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3838
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3841
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3844
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3847
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3850
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3853
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3856
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3859
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3862
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3865
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3868
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3871
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3874
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3877
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3880
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3883
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3886
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3889
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3892
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3895
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3898
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3901
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3904
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3907
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3910
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3913
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3916
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3919
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3922
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3925
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3928
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3931
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3934
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3937
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000011920929),
+      value("f32", 0.00000011920929),
+      value("f32", 0.00000011920929),
+      value("f32", 0.00000011920929),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3940
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000011920929),
+      value("f32", -0.00000011920929),
+      value("f32", -0.00000011920929),
+      value("f32", -0.00000011920929),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3943
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3946
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3949
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3952
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3955
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3958
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3961
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3964
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3967
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3970
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3973
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3976
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3979
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3982
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3985
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.00000011920929),
+      value("f32", -0.00000011920929),
+      value("f32", -0.00000011920929),
+      value("f32", -0.00000011920929),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3988
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000011920929),
+      value("f32", 0.00000011920929),
+      value("f32", 0.00000011920929),
+      value("f32", 0.00000011920929),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3991
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+      value("f32", -0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3994
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+      value("f32", 0.000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:3997
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4000
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4003
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4006
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4009
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4012
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4015
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4018
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4021
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4024
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4027
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 8388608),
+      value("f32", 8388608),
+      value("f32", 8388608),
+      value("f32", 8388608),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4030
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -8388608),
+      value("f32", -8388608),
+      value("f32", -8388608),
+      value("f32", -8388608),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4033
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4036
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4039
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4042
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4045
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4048
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4051
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000001870857),
+      value("f32", 0.000000000000000000000000000000000000001870857),
+      value("f32", 0.000000000000000000000000000000000000001870857),
+      value("f32", 0.000000000000000000000000000000000000001870857),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4054
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000001870857),
+      value("f32", -0.000000000000000000000000000000000000001870857),
+      value("f32", -0.000000000000000000000000000000000000001870857),
+      value("f32", -0.000000000000000000000000000000000000001870857),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4057
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4060
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4063
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4066
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4069
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4072
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4075
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -8388608),
+      value("f32", -8388608),
+      value("f32", -8388608),
+      value("f32", -8388608),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4078
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 8388608),
+      value("f32", 8388608),
+      value("f32", 8388608),
+      value("f32", 8388608),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4081
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4084
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4087
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+      value("f32", -0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4090
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+      value("f32", 0.000000000000000000000000000000000000023509887),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4093
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4096
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4099
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000001870857),
+      value("f32", -0.000000000000000000000000000000000000001870857),
+      value("f32", -0.000000000000000000000000000000000000001870857),
+      value("f32", -0.000000000000000000000000000000000000001870857),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4102
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000001870857),
+      value("f32", 0.000000000000000000000000000000000000001870857),
+      value("f32", 0.000000000000000000000000000000000000001870857),
+      value("f32", 0.000000000000000000000000000000000000001870857),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4105
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4108
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4111
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4114
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4117
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4120
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4123
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4126
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4129
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42535296000000000000000000000000000000),
+      value("f32", 42535296000000000000000000000000000000),
+      value("f32", 42535296000000000000000000000000000000),
+      value("f32", 42535296000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4132
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42535296000000000000000000000000000000),
+      value("f32", -42535296000000000000000000000000000000),
+      value("f32", -42535296000000000000000000000000000000),
+      value("f32", -42535296000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4135
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4138
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4141
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4144
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4147
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.07957747),
+      value("f32", 0.07957747),
+      value("f32", 0.07957747),
+      value("f32", 0.07957747),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4150
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.07957747),
+      value("f32", -0.07957747),
+      value("f32", -0.07957747),
+      value("f32", -0.07957747),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4153
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000001469368),
+      value("f32", 0.000000000000000000000000000000000000001469368),
+      value("f32", 0.000000000000000000000000000000000000001469368),
+      value("f32", 0.000000000000000000000000000000000000001469368),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4156
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000001469368),
+      value("f32", -0.000000000000000000000000000000000000001469368),
+      value("f32", -0.000000000000000000000000000000000000001469368),
+      value("f32", -0.000000000000000000000000000000000000001469368),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4159
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4162
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4165
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4168
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4171
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4174
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4177
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42535296000000000000000000000000000000),
+      value("f32", -42535296000000000000000000000000000000),
+      value("f32", -42535296000000000000000000000000000000),
+      value("f32", -42535296000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4180
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42535296000000000000000000000000000000),
+      value("f32", 42535296000000000000000000000000000000),
+      value("f32", 42535296000000000000000000000000000000),
+      value("f32", 42535296000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4183
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4186
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4189
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4192
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4195
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.07957747),
+      value("f32", -0.07957747),
+      value("f32", -0.07957747),
+      value("f32", -0.07957747),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4198
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.07957747),
+      value("f32", 0.07957747),
+      value("f32", 0.07957747),
+      value("f32", 0.07957747),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4201
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000001469368),
+      value("f32", -0.000000000000000000000000000000000000001469368),
+      value("f32", -0.000000000000000000000000000000000000001469368),
+      value("f32", -0.000000000000000000000000000000000000001469368),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4204
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000001469368),
+      value("f32", 0.000000000000000000000000000000000000001469368),
+      value("f32", 0.000000000000000000000000000000000000001469368),
+      value("f32", 0.000000000000000000000000000000000000001469368),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4207
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4210
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4213
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4216
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4219
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4222
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4225
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85070590000000000000000000000000000000),
+      value("f32", 85070590000000000000000000000000000000),
+      value("f32", 85070590000000000000000000000000000000),
+      value("f32", 85070590000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4228
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -85070590000000000000000000000000000000),
+      value("f32", -85070590000000000000000000000000000000),
+      value("f32", -85070590000000000000000000000000000000),
+      value("f32", -85070590000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4231
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4234
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4237
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4240
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4243
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.15915494),
+      value("f32", 0.15915494),
+      value("f32", 0.15915494),
+      value("f32", 0.15915494),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4246
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.15915494),
+      value("f32", -0.15915494),
+      value("f32", -0.15915494),
+      value("f32", -0.15915494),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4249
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000002938736),
+      value("f32", 0.000000000000000000000000000000000000002938736),
+      value("f32", 0.000000000000000000000000000000000000002938736),
+      value("f32", 0.000000000000000000000000000000000000002938736),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4252
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000002938736),
+      value("f32", -0.000000000000000000000000000000000000002938736),
+      value("f32", -0.000000000000000000000000000000000000002938736),
+      value("f32", -0.000000000000000000000000000000000000002938736),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4255
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4258
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4261
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4264
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4267
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4270
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4273
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -85070590000000000000000000000000000000),
+      value("f32", -85070590000000000000000000000000000000),
+      value("f32", -85070590000000000000000000000000000000),
+      value("f32", -85070590000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4276
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 85070590000000000000000000000000000000),
+      value("f32", 85070590000000000000000000000000000000),
+      value("f32", 85070590000000000000000000000000000000),
+      value("f32", 85070590000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4279
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+      value("f32", -2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4282
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4285
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4288
+assert_return(
+  () => invoke($0, `f32x4.div`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4291
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.15915494),
+      value("f32", -0.15915494),
+      value("f32", -0.15915494),
+      value("f32", -0.15915494),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4294
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.15915494),
+      value("f32", 0.15915494),
+      value("f32", 0.15915494),
+      value("f32", 0.15915494),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4297
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000002938736),
+      value("f32", -0.000000000000000000000000000000000000002938736),
+      value("f32", -0.000000000000000000000000000000000000002938736),
+      value("f32", -0.000000000000000000000000000000000000002938736),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4300
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000002938736),
+      value("f32", 0.000000000000000000000000000000000000002938736),
+      value("f32", 0.000000000000000000000000000000000000002938736),
+      value("f32", 0.000000000000000000000000000000000000002938736),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4303
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4306
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4309
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4312
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4315
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4318
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4321
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4324
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4327
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4330
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4333
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4336
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4339
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4342
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4345
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000018464624),
+      value("f32", 0.000000000000000000000000000000000000018464624),
+      value("f32", 0.000000000000000000000000000000000000018464624),
+      value("f32", 0.000000000000000000000000000000000000018464624),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4348
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000018464624),
+      value("f32", -0.000000000000000000000000000000000000018464624),
+      value("f32", -0.000000000000000000000000000000000000018464624),
+      value("f32", -0.000000000000000000000000000000000000018464624),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4351
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4354
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4357
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4360
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4363
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4366
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4369
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4372
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4375
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+      value("f32", -12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4378
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+      value("f32", 12.566371),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4381
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4384
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4387
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4390
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4393
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000018464624),
+      value("f32", -0.000000000000000000000000000000000000018464624),
+      value("f32", -0.000000000000000000000000000000000000018464624),
+      value("f32", -0.000000000000000000000000000000000000018464624),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4396
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000018464624),
+      value("f32", 0.000000000000000000000000000000000000018464624),
+      value("f32", 0.000000000000000000000000000000000000018464624),
+      value("f32", 0.000000000000000000000000000000000000018464624),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4399
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4402
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4405
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4408
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4411
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4414
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4417
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4420
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4423
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4426
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4429
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4432
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4435
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 54157613000000000000000000000000000000),
+      value("f32", 54157613000000000000000000000000000000),
+      value("f32", 54157613000000000000000000000000000000),
+      value("f32", 54157613000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4438
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -54157613000000000000000000000000000000),
+      value("f32", -54157613000000000000000000000000000000),
+      value("f32", -54157613000000000000000000000000000000),
+      value("f32", -54157613000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4441
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4444
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4447
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4450
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4453
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4456
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4459
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4462
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4465
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4468
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4471
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4474
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4477
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4480
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4483
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -54157613000000000000000000000000000000),
+      value("f32", -54157613000000000000000000000000000000),
+      value("f32", -54157613000000000000000000000000000000),
+      value("f32", -54157613000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4486
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 54157613000000000000000000000000000000),
+      value("f32", 54157613000000000000000000000000000000),
+      value("f32", 54157613000000000000000000000000000000),
+      value("f32", 54157613000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4489
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4492
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4495
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4498
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4501
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4504
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4507
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4510
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4513
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4516
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4519
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4522
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4525
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4528
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4531
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4534
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4537
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4540
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4543
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4546
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4549
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4552
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4555
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4558
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4561
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4564
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4567
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4570
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4573
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4576
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4579
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4582
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4585
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4588
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4591
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4594
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4597
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4600
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4603
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4606
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4609
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4612
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4615
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4618
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4621
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4624
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4627
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4630
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4633
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4636
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4639
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4642
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4645
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4648
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4651
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4654
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4657
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4660
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4663
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4666
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4669
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4672
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4675
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4678
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4681
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4684
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4687
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4690
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4693
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4696
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4699
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4702
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4705
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4708
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4711
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4714
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4717
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4720
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4723
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4726
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4729
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4732
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4735
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4738
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4741
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4744
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4747
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4750
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4753
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4756
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4759
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4762
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4765
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4768
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4771
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4774
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4777
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4780
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4783
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4786
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4789
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4792
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4795
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4798
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4801
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4804
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4807
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4810
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4813
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4816
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4819
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4822
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4825
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4828
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4831
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4834
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4837
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4840
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4843
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4846
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4849
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4852
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4855
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4858
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4861
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4864
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4867
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4870
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4873
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4876
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4879
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4882
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4885
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4888
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4891
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4894
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4897
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4900
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4903
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4906
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4909
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4912
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4915
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4918
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4921
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4924
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4927
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4930
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4933
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4936
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4939
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4942
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4945
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4948
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4951
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4954
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4957
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4960
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4963
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4966
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4969
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4972
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4975
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4978
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4981
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4984
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4987
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4990
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4993
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4996
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:4999
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5002
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5005
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5008
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5011
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5014
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5017
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5020
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5023
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5026
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5029
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5032
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5035
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5038
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5041
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5044
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5047
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5050
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5053
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5056
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5059
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5062
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5065
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5068
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5071
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5074
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5077
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5080
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5083
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5086
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5089
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5092
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5095
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5098
+assert_return(
+  () => invoke($0, `f32x4.div`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5101
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5103
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5105
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000003743392),
+      value("f32", 0.00000000000000000000003743392),
+      value("f32", 0.00000000000000000000003743392),
+      value("f32", 0.00000000000000000000003743392),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5107
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5109
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000010842022),
+      value("f32", 0.00000000000000000010842022),
+      value("f32", 0.00000000000000000010842022),
+      value("f32", 0.00000000000000000010842022),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5111
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5113
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.70710677),
+      value("f32", 0.70710677),
+      value("f32", 0.70710677),
+      value("f32", 0.70710677),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5115
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5117
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5119
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5121
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855])]),
+  [
+    new F32x4Pattern(
+      value("f32", 2.5066283),
+      value("f32", 2.5066283),
+      value("f32", 2.5066283),
+      value("f32", 2.5066283),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5123
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5125
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 18446743000000000000),
+      value("f32", 18446743000000000000),
+      value("f32", 18446743000000000000),
+      value("f32", 18446743000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5127
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5129
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5131
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5133
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5135
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5137
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5139
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5141
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5143
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5145
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5147
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5149
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5151
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5153
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5155
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5157
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+      value("f32", 11111.111),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5159
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5161
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+      value("f32", 35136419000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5163
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+      value("f32", 0.0000035136418),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5165
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 286331170),
+      value("f32", 286331170),
+      value("f32", 286331170),
+      value("f32", 286331170),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5167
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5169
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5171
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5173
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 286331170),
+      value("f32", 286331170),
+      value("f32", 286331170),
+      value("f32", 286331170),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5175
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5177
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5179
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5181
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 286331170),
+      value("f32", 286331170),
+      value("f32", 286331170),
+      value("f32", 286331170),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5183
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5185
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+      value("f32", 207325900000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5187
+assert_return(
+  () => invoke($0, `f32x4.sqrt`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+      value("f32", 395442.78),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5189
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5191
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5193
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5195
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5197
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5199
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5201
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5203
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5205
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5207
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5209
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855])]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5211
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5213
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5215
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5217
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5219
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5221
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5223
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5225
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5227
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5229
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5231
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5233
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5235
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5237
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5239
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5241
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5243
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5245
+assert_return(
+  () => invoke($0, `f32x4.neg`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+      value("f32", -123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5247
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5249
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+      value("f32", -1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5251
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+      value("f32", -0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5253
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5255
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5257
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5259
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5261
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5263
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5265
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5267
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5269
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+      value("f32", -81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5271
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5273
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+      value("f32", -42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5275
+assert_return(
+  () => invoke($0, `f32x4.neg`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+      value("f32", -156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5280
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5290
+assert_return(
+  () => invoke($1, `f32x4_sqrt_arith`, []),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      value("f32", 4),
+      value("f32", 5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5291
+assert_return(
+  () => invoke($1, `f32x4_sqrt_canon`, []),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5292
+assert_return(
+  () => invoke($1, `f32x4_sqrt_mixed`, []),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `arithmetic_nan`,
+      value("f32", 6),
+      value("f32", 7),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5295
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.neg (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5296
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.sqrt (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5297
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.add (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5298
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.sub (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5299
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5300
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5304
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.neg-arg-empty (result v128)
+      (f32x4.neg)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5312
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.sqrt-arg-empty (result v128)
+      (f32x4.sqrt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5320
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.add-1st-arg-empty (result v128)
+      (f32x4.add (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5328
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.add-arg-empty (result v128)
+      (f32x4.add)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5336
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.sub-1st-arg-empty (result v128)
+      (f32x4.sub (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5344
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.sub-arg-empty (result v128)
+      (f32x4.sub)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5352
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.mul-1st-arg-empty (result v128)
+      (f32x4.mul (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5360
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.mul-arg-empty (result v128)
+      (f32x4.mul)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5368
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.div-1st-arg-empty (result v128)
+      (f32x4.div (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5376
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.div-arg-empty (result v128)
+      (f32x4.div)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5386
+let $2 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5421
+assert_return(
+  () => invoke($2, `add-sub`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5425
+assert_return(
+  () => invoke($2, `div-add`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 5),
+      value("f32", 5),
+      value("f32", 5),
+      value("f32", 5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5429
+assert_return(
+  () => invoke($2, `div-mul`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([4, 4, 4, 4]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 18),
+      value("f32", 18),
+      value("f32", 18),
+      value("f32", 18),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5433
+assert_return(
+  () => invoke($2, `div-sub`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 4),
+      value("f32", 4),
+      value("f32", 4),
+      value("f32", 4),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5437
+assert_return(
+  () => invoke($2, `mul-add`, [
+    f32x4([1.25, 1.25, 1.25, 1.25]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.375),
+      value("f32", 0.375),
+      value("f32", 0.375),
+      value("f32", 0.375),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5441
+assert_return(
+  () => invoke($2, `mul-div`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 2.25),
+      value("f32", 2.25),
+      value("f32", 2.25),
+      value("f32", 2.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5445
+assert_return(
+  () => invoke($2, `mul-sub`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+      value("f32", 0.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5449
+assert_return(
+  () => invoke($2, `sub-add`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.25),
+      value("f32", 1.25),
+      value("f32", 1.25),
+      value("f32", 1.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5453
+assert_return(
+  () => invoke($2, `add-neg`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5456
+assert_return(
+  () => invoke($2, `add-sqrt`, [
+    f32x4([2.25, 2.25, 2.25, 2.25]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.75),
+      value("f32", 1.75),
+      value("f32", 1.75),
+      value("f32", 1.75),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5459
+assert_return(
+  () => invoke($2, `div-neg`, [
+    f32x4([1.5, 1.5, 1.5, 1.5]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5462
+assert_return(
+  () => invoke($2, `div-sqrt`, [
+    f32x4([2.25, 2.25, 2.25, 2.25]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5465
+assert_return(
+  () => invoke($2, `mul-neg`, [
+    f32x4([1.5, 1.5, 1.5, 1.5]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.375),
+      value("f32", -0.375),
+      value("f32", -0.375),
+      value("f32", -0.375),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5468
+assert_return(
+  () => invoke($2, `mul-sqrt`, [
+    f32x4([2.25, 2.25, 2.25, 2.25]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.375),
+      value("f32", 0.375),
+      value("f32", 0.375),
+      value("f32", 0.375),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5471
+assert_return(
+  () => invoke($2, `sub-neg`, [
+    f32x4([1.125, 1.125, 1.125, 1.125]),
+    f32x4([0.125, 0.125, 0.125, 0.125]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1.25),
+      value("f32", -1.25),
+      value("f32", -1.25),
+      value("f32", -1.25),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_arith.wast:5474
+assert_return(
+  () => invoke($2, `sub-sqrt`, [
+    f32x4([2.25, 2.25, 2.25, 2.25]),
+    f32x4([0.25, 0.25, 0.25, 0.25]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.25),
+      value("f32", 1.25),
+      value("f32", 1.25),
+      value("f32", 1.25),
+    ),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js
new file mode 100644
index 0000000000..e11d19597a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_cmp.wast.js
@@ -0,0 +1,47701 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f32x4_cmp.wast
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:13
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:16
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:19
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:22
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:25
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:28
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:31
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:34
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:37
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:40
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:43
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:46
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:49
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:52
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:55
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:58
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:61
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:64
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:67
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:70
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:73
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:76
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:79
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:82
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:85
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:88
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:91
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:94
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:97
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:100
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:103
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:106
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:109
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:112
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:115
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:118
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:121
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:124
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:127
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:130
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:133
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:136
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:139
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:142
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:145
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:148
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:151
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:154
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:157
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:160
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:163
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:166
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:169
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:172
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:175
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:178
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:181
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:184
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:187
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:190
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:193
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:196
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:199
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:202
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:205
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:208
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:211
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:214
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:217
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:220
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:223
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:226
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:229
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:232
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:235
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:238
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:241
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:244
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:247
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:250
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:253
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:256
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:259
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:262
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:265
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:268
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:271
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:274
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:277
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:280
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:283
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:286
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:289
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:292
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:295
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:298
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:301
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:304
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:307
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:310
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:313
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:316
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:319
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:322
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:325
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:328
+assert_return(
+  () => invoke($0, `eq`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:331
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:334
+assert_return(
+  () => invoke($0, `eq`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:337
+assert_return(
+  () => invoke($0, `eq`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:340
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:343
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:346
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:349
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:352
+assert_return(
+  () => invoke($0, `eq`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:355
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:358
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:361
+assert_return(
+  () => invoke($0, `eq`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:364
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:367
+assert_return(
+  () => invoke($0, `eq`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:370
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:373
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:376
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:379
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:382
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:385
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:388
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:391
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:394
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:397
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:400
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:403
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:406
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:409
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:412
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:415
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:418
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:421
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:424
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:427
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:430
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:433
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:436
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:439
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:442
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:445
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:448
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:451
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:454
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:457
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0, -0, -0, -0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:460
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:463
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:466
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:469
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:472
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:475
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:478
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:481
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:484
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:487
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:490
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:493
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:496
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:499
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:502
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:505
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:508
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:511
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:514
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:517
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:520
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:523
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:526
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:529
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:532
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:535
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:538
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:541
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:544
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:547
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:550
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:553
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:556
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:559
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:562
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:565
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:568
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:571
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:574
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:577
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:580
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:583
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:586
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:589
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:592
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:595
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:598
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:601
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:604
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:607
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:610
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:613
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:616
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:619
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:622
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:625
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:628
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:631
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:634
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:637
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:640
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:643
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:646
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:649
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:652
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:655
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:658
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:661
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:664
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:667
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:670
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:673
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:676
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:679
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:682
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:685
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:688
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:691
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:694
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:697
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:700
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:703
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:706
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:709
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:712
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:715
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:718
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:721
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:724
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:727
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:730
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:733
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:736
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:739
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:742
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:745
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:748
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:751
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:754
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:757
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:760
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:763
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:766
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:769
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:772
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:775
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:778
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:781
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:784
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:787
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:790
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:793
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:796
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:799
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:802
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:805
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:808
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:811
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:814
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:817
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:820
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:823
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:826
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:829
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:832
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:835
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:838
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:841
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:844
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:847
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:850
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:853
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:856
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:859
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:862
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:865
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:868
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:871
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:874
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:877
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:880
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:883
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:886
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:889
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:892
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:895
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:898
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:901
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:904
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:907
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:910
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:913
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:916
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:919
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:922
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:925
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:928
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:931
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:934
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:937
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:940
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:943
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:946
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:949
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:952
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:955
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:958
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:961
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:964
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:967
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:970
+assert_return(
+  () => invoke($0, `eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:973
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:976
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:979
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:982
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:985
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:988
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:991
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:994
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:997
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1000
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1003
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1006
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1009
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1012
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1015
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1018
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1021
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1024
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1027
+assert_return(
+  () => invoke($0, `eq`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1030
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1033
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1036
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1039
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1042
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1045
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1048
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1051
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1054
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1057
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1060
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1063
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1066
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1069
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1072
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1075
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1078
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1081
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1084
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1087
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1090
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1093
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1096
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1099
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1102
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1105
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1108
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1111
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1114
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1117
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, -1, -1, -1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1120
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1123
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1126
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1129
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1132
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1135
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1138
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1141
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1144
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1147
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1150
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1153
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1156
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1159
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1162
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1165
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1168
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1171
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1174
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1177
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1180
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1183
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1186
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1189
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1192
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1195
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1198
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1201
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1204
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1207
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1210
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1213
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1216
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1219
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1222
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1225
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1228
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1231
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1234
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1237
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1240
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1243
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1246
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1249
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1252
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1255
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1258
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1261
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1264
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1267
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1270
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1273
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1276
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1279
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1282
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1285
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1290
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1293
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1296
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1299
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1302
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1305
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1308
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1311
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1314
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1317
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1320
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1323
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1326
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1329
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1332
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1335
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1338
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1341
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1344
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1347
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1350
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1353
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1356
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1359
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1362
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1365
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1368
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1371
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1374
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1377
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1380
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1383
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1386
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1389
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1392
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1395
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1398
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1401
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1404
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1407
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1410
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1413
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1416
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1419
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1422
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1425
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1428
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1431
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1434
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1437
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1440
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1443
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1446
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1449
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1452
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1455
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1458
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1461
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1464
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1467
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1470
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1473
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1476
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1479
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1482
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1485
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1488
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1491
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1494
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1497
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1500
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1503
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1506
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1509
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1512
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1515
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1518
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1521
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1524
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1527
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1530
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1533
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1536
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1539
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1542
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1545
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1548
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1551
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1554
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1557
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1560
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1563
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1566
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1569
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1572
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1575
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1578
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1581
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1584
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1587
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1590
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1593
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1596
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1599
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1602
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1605
+assert_return(
+  () => invoke($0, `ne`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1608
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1611
+assert_return(
+  () => invoke($0, `ne`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1614
+assert_return(
+  () => invoke($0, `ne`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1617
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1620
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1623
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1626
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1629
+assert_return(
+  () => invoke($0, `ne`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1632
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1635
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1638
+assert_return(
+  () => invoke($0, `ne`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1641
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1644
+assert_return(
+  () => invoke($0, `ne`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1647
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1650
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1653
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1656
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1659
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1662
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1665
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1668
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1671
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1674
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1677
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1680
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1683
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1686
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1689
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1692
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1695
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1698
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1701
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1704
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1707
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1710
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1713
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1716
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1719
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1722
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1725
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1728
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1731
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1734
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0, -0, -0, -0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1737
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1740
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1743
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1746
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1749
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1752
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1755
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1758
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1761
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1764
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1767
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1770
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1773
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1776
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1779
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1782
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1785
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1788
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1791
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1794
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1797
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1800
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1803
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1806
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1809
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1812
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1815
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1818
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1821
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1824
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1827
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1830
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1833
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1836
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1839
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1842
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1845
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1848
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1851
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1854
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1857
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1860
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1863
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1866
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1869
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1872
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1875
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1878
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1881
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1884
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1887
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1890
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1893
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1896
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1899
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1902
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1905
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1908
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1911
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1914
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1917
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1920
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1923
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1926
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1929
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1932
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1935
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1938
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1941
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1944
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1947
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1950
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1953
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1956
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1959
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1962
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1965
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1968
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1971
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1974
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1977
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1980
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1983
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1986
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1989
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1992
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1995
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:1998
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2001
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2004
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2007
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2010
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2013
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2016
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2019
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2022
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2025
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2028
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2031
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2034
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2037
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2040
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2043
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2046
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2049
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2052
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2055
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2058
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2061
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2064
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2067
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2070
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2073
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2076
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2079
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2082
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2085
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2088
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2091
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2094
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2097
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2100
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2103
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2106
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2109
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2112
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2115
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2118
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2121
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2124
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2127
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2130
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2133
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2136
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2139
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2142
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2145
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2148
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2151
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2154
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2157
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2160
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2163
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2166
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2169
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2172
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2175
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2178
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2181
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2184
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2187
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2190
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2193
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2196
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2199
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2202
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2205
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2208
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2211
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2214
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2217
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2220
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2223
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2226
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2229
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2232
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2235
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2238
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2241
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2244
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2247
+assert_return(
+  () => invoke($0, `ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2250
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2253
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2256
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2259
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2262
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2265
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2268
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2271
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2274
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2277
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2280
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2283
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2286
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2289
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2292
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2295
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2298
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2301
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2304
+assert_return(
+  () => invoke($0, `ne`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2307
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2310
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2313
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2316
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2319
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2322
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2325
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2328
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2331
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2334
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2337
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2340
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2343
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2346
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2349
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2352
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2355
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2358
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2361
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2364
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2367
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2370
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2373
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2376
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2379
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2382
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2385
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2388
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2391
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2394
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, -1, -1, -1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2397
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2400
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2403
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2406
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2409
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2412
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2415
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2418
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2421
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2424
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2427
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2430
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2433
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2436
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2439
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2442
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2445
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2448
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2451
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2454
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2457
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2460
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2463
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2466
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2469
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2472
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2475
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2478
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2481
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2484
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2487
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2490
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2493
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2496
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2499
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2502
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2505
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2508
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2511
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2514
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2517
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2520
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2523
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2526
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2529
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2532
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2535
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2538
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2541
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2544
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2547
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2550
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2553
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2556
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2559
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2562
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2567
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2570
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2573
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2576
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2579
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2582
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2585
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2588
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2591
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2594
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2597
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2600
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2603
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2606
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2609
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2612
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2615
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2618
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2621
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2624
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2627
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2630
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2633
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2636
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2639
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2642
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2645
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2648
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2651
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2654
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2657
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2660
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2663
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2666
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2669
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2672
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2675
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2678
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2681
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2684
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2687
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2690
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2693
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2696
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2699
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2702
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2705
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2708
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2711
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2714
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2717
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2720
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2723
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2726
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2729
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2732
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2735
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2738
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2741
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2744
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2747
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2750
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2753
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2756
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2759
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2762
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2765
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2768
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2771
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2774
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2777
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2780
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2783
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2786
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2789
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2792
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2795
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2798
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2801
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2804
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2807
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2810
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2813
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2816
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2819
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2822
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2825
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2828
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2831
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2834
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2837
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2840
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2843
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2846
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2849
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2852
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2855
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2858
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2861
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2864
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2867
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2870
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2873
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2876
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2879
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2882
+assert_return(
+  () => invoke($0, `lt`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2885
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2888
+assert_return(
+  () => invoke($0, `lt`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2891
+assert_return(
+  () => invoke($0, `lt`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2894
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2897
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2900
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2903
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2906
+assert_return(
+  () => invoke($0, `lt`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2909
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2912
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2915
+assert_return(
+  () => invoke($0, `lt`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2918
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2921
+assert_return(
+  () => invoke($0, `lt`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2924
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2927
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2930
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2933
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2936
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2939
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2942
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2945
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2948
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2951
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2954
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2957
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2960
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2963
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2966
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2969
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2972
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2975
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2978
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2981
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2984
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2987
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2990
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2993
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2996
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:2999
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3002
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3005
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3008
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3011
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0, -0, -0, -0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3014
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3017
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3020
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3023
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3026
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3029
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3032
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3035
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3038
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3041
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3044
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3047
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3050
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3053
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3056
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3059
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3062
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3065
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3068
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3071
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3074
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3077
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3080
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3083
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3086
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3089
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3092
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3095
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3098
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3101
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3104
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3107
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3110
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3113
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3116
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3119
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3122
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3125
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3128
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3131
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3134
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3137
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3140
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3143
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3146
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3149
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3152
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3155
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3158
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3161
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3164
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3167
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3170
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3173
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3176
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3179
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3182
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3185
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3188
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3191
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3194
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3197
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3200
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3203
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3206
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3209
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3212
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3215
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3218
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3221
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3224
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3227
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3230
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3233
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3236
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3239
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3242
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3245
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3248
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3251
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3254
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3257
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3260
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3263
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3266
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3269
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3272
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3275
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3278
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3281
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3284
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3287
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3290
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3293
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3296
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3299
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3302
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3305
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3308
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3311
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3314
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3317
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3320
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3323
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3326
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3329
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3332
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3335
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3338
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3341
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3344
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3347
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3350
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3353
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3356
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3359
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3362
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3365
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3368
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3371
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3374
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3377
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3380
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3383
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3386
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3389
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3392
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3395
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3398
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3401
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3404
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3407
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3410
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3413
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3416
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3419
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3422
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3425
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3428
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3431
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3434
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3437
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3440
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3443
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3446
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3449
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3452
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3455
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3458
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3461
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3464
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3467
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3470
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3473
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3476
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3479
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3482
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3485
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3488
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3491
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3494
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3497
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3500
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3503
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3506
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3509
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3512
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3515
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3518
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3521
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3524
+assert_return(
+  () => invoke($0, `lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3527
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3530
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3533
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3536
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3539
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3542
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3545
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3548
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3551
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3554
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3557
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3560
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3563
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3566
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3569
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3572
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3575
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3578
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3581
+assert_return(
+  () => invoke($0, `lt`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3584
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3587
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3590
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3593
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3596
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3599
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3602
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3605
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3608
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3611
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3614
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3617
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3620
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3623
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3626
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3629
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3632
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3635
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3638
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3641
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3644
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3647
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3650
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3653
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3656
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3659
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3662
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3665
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3668
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3671
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, -1, -1, -1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3674
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3677
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3680
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3683
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3686
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3689
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3692
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3695
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3698
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3701
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3704
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3707
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3710
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3713
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3716
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3719
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3722
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3725
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3728
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3731
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3734
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3737
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3740
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3743
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3746
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3749
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3752
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3755
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3758
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3761
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3764
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3767
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3770
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3773
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3776
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3779
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3782
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3785
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3788
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3791
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3794
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3797
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3800
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3803
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3806
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3809
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3812
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3815
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3818
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3821
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3824
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3827
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3830
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3833
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3836
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3839
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3844
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3847
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3850
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3853
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3856
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3859
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3862
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3865
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3868
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3871
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3874
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3877
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3880
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3883
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3886
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3889
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3892
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3895
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3898
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3901
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3904
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3907
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3910
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3913
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3916
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3919
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3922
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3925
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3928
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3931
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3934
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3937
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3940
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3943
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3946
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3949
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3952
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3955
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3958
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3961
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3964
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3967
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3970
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3973
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3976
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3979
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3982
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3985
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3988
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3991
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3994
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:3997
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4000
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4003
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4006
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4009
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4012
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4015
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4018
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4021
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4024
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4027
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4030
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4033
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4036
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4039
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4042
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4045
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4048
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4051
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4054
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4057
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4060
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4063
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4066
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4069
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4072
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4075
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4078
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4081
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4084
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4087
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4090
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4093
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4096
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4099
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4102
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4105
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4108
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4111
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4114
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4117
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4120
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4123
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4126
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4129
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4132
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4135
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4138
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4141
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4144
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4147
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4150
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4153
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4156
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4159
+assert_return(
+  () => invoke($0, `le`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4162
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4165
+assert_return(
+  () => invoke($0, `le`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4168
+assert_return(
+  () => invoke($0, `le`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4171
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4174
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4177
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4180
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4183
+assert_return(
+  () => invoke($0, `le`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4186
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4189
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4192
+assert_return(
+  () => invoke($0, `le`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4195
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4198
+assert_return(
+  () => invoke($0, `le`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4201
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4204
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4207
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4210
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4213
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4216
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4219
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4222
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4225
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4228
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4231
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4234
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4237
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4240
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4243
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4246
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4249
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4252
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4255
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4258
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4261
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4264
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4267
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4270
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4273
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4276
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4279
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4282
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4285
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4288
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0, -0, -0, -0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4291
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4294
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4297
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4300
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4303
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4306
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4309
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4312
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4315
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4318
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4321
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4324
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4327
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4330
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4333
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4336
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4339
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4342
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4345
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4348
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4351
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4354
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4357
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4360
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4363
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4366
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4369
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4372
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4375
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4378
+assert_return(
+  () => invoke($0, `le`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4381
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4384
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4387
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4390
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4393
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4396
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4399
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4402
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4405
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4408
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4411
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4414
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4417
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4420
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4423
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4426
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4429
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4432
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4435
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4438
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4441
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4444
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4447
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4450
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4453
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4456
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4459
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4462
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4465
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4468
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4471
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4474
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4477
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4480
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4483
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4486
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4489
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4492
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4495
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4498
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4501
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4504
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4507
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4510
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4513
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4516
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4519
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4522
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4525
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4528
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4531
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4534
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4537
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4540
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4543
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4546
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4549
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4552
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4555
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4558
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4561
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4564
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4567
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4570
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4573
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4576
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4579
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4582
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4585
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4588
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4591
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4594
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4597
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4600
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4603
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4606
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4609
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4612
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4615
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4618
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4621
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4624
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4627
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4630
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4633
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4636
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4639
+assert_return(
+  () => invoke($0, `le`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4642
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4645
+assert_return(
+  () => invoke($0, `le`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4648
+assert_return(
+  () => invoke($0, `le`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4651
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4654
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4657
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4660
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4663
+assert_return(
+  () => invoke($0, `le`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4666
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4669
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4672
+assert_return(
+  () => invoke($0, `le`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4675
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4678
+assert_return(
+  () => invoke($0, `le`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4681
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4684
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4687
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4690
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4693
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4696
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4699
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4702
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4705
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4708
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4711
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4714
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4717
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4720
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4723
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4726
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4729
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4732
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4735
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4738
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4741
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4744
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4747
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4750
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4753
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4756
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4759
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4762
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4765
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4768
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4771
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4774
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4777
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4780
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4783
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4786
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4789
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4792
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4795
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4798
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4801
+assert_return(
+  () => invoke($0, `le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4804
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4807
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4810
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4813
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4816
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4819
+assert_return(
+  () => invoke($0, `le`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4822
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4825
+assert_return(
+  () => invoke($0, `le`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4828
+assert_return(
+  () => invoke($0, `le`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4831
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4834
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4837
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4840
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4843
+assert_return(
+  () => invoke($0, `le`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4846
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4849
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4852
+assert_return(
+  () => invoke($0, `le`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4855
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4858
+assert_return(
+  () => invoke($0, `le`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4861
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4864
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4867
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4870
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4873
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4876
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4879
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4882
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4885
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4888
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4891
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4894
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4897
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4900
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4903
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4906
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4909
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4912
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4915
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4918
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4921
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4924
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4927
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4930
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4933
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4936
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4939
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4942
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4945
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4948
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, -1, -1, -1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4951
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4954
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4957
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4960
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4963
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4966
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4969
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4972
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4975
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4978
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4981
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4984
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4987
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4990
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4993
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4996
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:4999
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5002
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5005
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5008
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5011
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5014
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5017
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5020
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5023
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5026
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5029
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5032
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5035
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5038
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5041
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5044
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5047
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5050
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5053
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5056
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5059
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5062
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5065
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5068
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5071
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5074
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5077
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5080
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5083
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5086
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5089
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5092
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5095
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5098
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5101
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5104
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5107
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5110
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5113
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5116
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5121
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5124
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5127
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5130
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5133
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5136
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5139
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5142
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5145
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5148
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5151
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5154
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5157
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5160
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5163
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5166
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5169
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5172
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5175
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5178
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5181
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5184
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5187
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5190
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5193
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5196
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5199
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5202
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5205
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5208
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5211
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5214
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5217
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5220
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5223
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5226
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5229
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5232
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5235
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5238
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5241
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5244
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5247
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5250
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5253
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5256
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5259
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5262
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5265
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5268
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5271
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5274
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5277
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5280
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5283
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5286
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5289
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5292
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5295
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5298
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5301
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5304
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5307
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5310
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5313
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5316
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5319
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5322
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5325
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5328
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5331
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5334
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5337
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5340
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5343
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5346
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5349
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5352
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5355
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5358
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5361
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5364
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5367
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5370
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5373
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5376
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5379
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5382
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5385
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5388
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5391
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5394
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5397
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5400
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5403
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5406
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5409
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5412
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5415
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5418
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5421
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5424
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5427
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5430
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5433
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5436
+assert_return(
+  () => invoke($0, `gt`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5439
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5442
+assert_return(
+  () => invoke($0, `gt`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5445
+assert_return(
+  () => invoke($0, `gt`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5448
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5451
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5454
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5457
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5460
+assert_return(
+  () => invoke($0, `gt`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5463
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5466
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5469
+assert_return(
+  () => invoke($0, `gt`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5472
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5475
+assert_return(
+  () => invoke($0, `gt`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5478
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5481
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5484
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5487
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5490
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5493
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5496
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5499
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5502
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5505
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5508
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5511
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5514
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5517
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5520
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5523
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5526
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5529
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5532
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5535
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5538
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5541
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5544
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5547
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5550
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5553
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5556
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5559
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5562
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5565
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0, -0, -0, -0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5568
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5571
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5574
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5577
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5580
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5583
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5586
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5589
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5592
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5595
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5598
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5601
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5604
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5607
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5610
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5613
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5616
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5619
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5622
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5625
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5628
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5631
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5634
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5637
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5640
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5643
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5646
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5649
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5652
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5655
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5658
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5661
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5664
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5667
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5670
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5673
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5676
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5679
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5682
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5685
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5688
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5691
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5694
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5697
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5700
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5703
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5706
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5709
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5712
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5715
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5718
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5721
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5724
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5727
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5730
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5733
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5736
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5739
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5742
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5745
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5748
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5751
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5754
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5757
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5760
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5763
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5766
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5769
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5772
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5775
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5778
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5781
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5784
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5787
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5790
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5793
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5796
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5799
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5802
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5805
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5808
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5811
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5814
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5817
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5820
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5823
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5826
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5829
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5832
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5835
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5838
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5841
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5844
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5847
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5850
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5853
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5856
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5859
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5862
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5865
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5868
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5871
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5874
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5877
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5880
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5883
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5886
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5889
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5892
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5895
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5898
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5901
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5904
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5907
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5910
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5913
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5916
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5919
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5922
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5925
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5928
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5931
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5934
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5937
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5940
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5943
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5946
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5949
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5952
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5955
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5958
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5961
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5964
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5967
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5970
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5973
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5976
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5979
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5982
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5985
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5988
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5991
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5994
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:5997
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6000
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6003
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6006
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6009
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6012
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6015
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6018
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6021
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6024
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6027
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6030
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6033
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6036
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6039
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6042
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6045
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6048
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6051
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6054
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6057
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6060
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6063
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6066
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6069
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6072
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6075
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6078
+assert_return(
+  () => invoke($0, `gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6081
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6084
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6087
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6090
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6093
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6096
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6099
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6102
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6105
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6108
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6111
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6114
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6117
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6120
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6123
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6126
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6129
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6132
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6135
+assert_return(
+  () => invoke($0, `gt`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6138
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6141
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6144
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6147
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6150
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6153
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6156
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6159
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6162
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6165
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6168
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6171
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6174
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6177
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6180
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6183
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6186
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6189
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6192
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6195
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6198
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6201
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6204
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6207
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6210
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6213
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6216
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6219
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6222
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6225
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, -1, -1, -1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6228
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6231
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6234
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6237
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6240
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6243
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6246
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6249
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6252
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6255
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6258
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6261
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6264
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6267
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6270
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6273
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6276
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6279
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6282
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6285
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6288
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6291
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6294
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6297
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6300
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6303
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6306
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6309
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6312
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6315
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6318
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6321
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6324
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6327
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6330
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6333
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6336
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6339
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6342
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6345
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6348
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6351
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6354
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6357
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6360
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6363
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6366
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6369
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6372
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6375
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6378
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6381
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6384
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6387
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6390
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6393
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6398
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6401
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6404
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6407
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6410
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6413
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6416
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6419
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6422
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6425
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6428
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6431
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6434
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6437
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6440
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6443
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6446
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6449
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6452
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6455
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6458
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6461
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6464
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6467
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6470
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6473
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6476
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6479
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6482
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6485
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6488
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6491
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6494
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6497
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6500
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6503
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6506
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6509
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6512
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6515
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6518
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6521
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6524
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6527
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6530
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6533
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6536
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6539
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6542
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6545
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6548
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6551
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6554
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6557
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6560
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6563
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6566
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6569
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6572
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6575
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6578
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6581
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6584
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6587
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6590
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6593
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6596
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6599
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6602
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6605
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6608
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6611
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6614
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6617
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6620
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6623
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6626
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6629
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6632
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6635
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6638
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6641
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6644
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6647
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6650
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6653
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6656
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6659
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6662
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6665
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6668
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6671
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6674
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6677
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6680
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6683
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6686
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6689
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6692
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6695
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6698
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6701
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6704
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6707
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6710
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6713
+assert_return(
+  () => invoke($0, `ge`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6716
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6719
+assert_return(
+  () => invoke($0, `ge`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6722
+assert_return(
+  () => invoke($0, `ge`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6725
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6728
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6731
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6734
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6737
+assert_return(
+  () => invoke($0, `ge`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6740
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6743
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6746
+assert_return(
+  () => invoke($0, `ge`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6749
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6752
+assert_return(
+  () => invoke($0, `ge`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6755
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6758
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6761
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6764
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6767
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6770
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6773
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6776
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6779
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6782
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6785
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6788
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6791
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6794
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6797
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6800
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6803
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6806
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6809
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6812
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6815
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6818
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6821
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6824
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6827
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6830
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6833
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6836
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6839
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6842
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0, -0, -0, -0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6845
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6848
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6851
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6854
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6857
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6860
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6863
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6866
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6869
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6872
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6875
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6878
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6881
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6884
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6887
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6890
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6893
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6896
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6899
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6902
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6905
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6908
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6911
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6914
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6917
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6920
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6923
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6926
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6929
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6932
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6935
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6938
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6941
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6944
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6947
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6950
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6953
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6956
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6959
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6962
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6965
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6968
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6971
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6974
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6977
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6980
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6983
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6986
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6989
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6992
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6995
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:6998
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7001
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7004
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7007
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7010
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7013
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7016
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7019
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7022
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7025
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7028
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7031
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7034
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7037
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7040
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7043
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7046
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7049
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7052
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7055
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7058
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7061
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7064
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7067
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7070
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7073
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7076
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7079
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7082
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7085
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7088
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7091
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7094
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7097
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7100
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7103
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7106
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7109
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7112
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7115
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7118
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7121
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7124
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7127
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7130
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7133
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7136
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7139
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7142
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7145
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7148
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7151
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7154
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7157
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7160
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7163
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7166
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7169
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7172
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7175
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7178
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7181
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7184
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7187
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7190
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7193
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7196
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7199
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7202
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7205
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7208
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7211
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7214
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7217
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7220
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7223
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7226
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7229
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7232
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7235
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7238
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7241
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7244
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7247
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7250
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7253
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7256
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7259
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7262
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7265
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7268
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7271
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7274
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7277
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7280
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7283
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7286
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7289
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7292
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7295
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7298
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7301
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7304
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7307
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7310
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7313
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7316
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7319
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7322
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7325
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7328
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7331
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7334
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7337
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7340
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7343
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7346
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7349
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7352
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7355
+assert_return(
+  () => invoke($0, `ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7358
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7361
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7364
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7367
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7370
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7373
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7376
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7379
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7382
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7385
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7388
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7391
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7394
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7397
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7400
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7403
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7406
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7409
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7412
+assert_return(
+  () => invoke($0, `ge`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7415
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7418
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7421
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7424
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7427
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7430
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7433
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7436
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7439
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7442
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7445
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7448
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7451
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7454
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7457
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7460
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7463
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7466
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7469
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7472
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7475
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7478
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7481
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7484
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7487
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7490
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7493
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7496
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7499
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7502
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, -1, -1, -1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7505
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7508
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7511
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7514
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7517
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7520
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7523
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7526
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7529
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7532
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7535
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7538
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7541
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7544
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7547
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7550
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7553
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7556
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7559
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7562
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7565
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7568
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7571
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7574
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7577
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7580
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7583
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7586
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7589
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7592
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7595
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7598
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7601
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7604
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7607
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7610
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7613
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7616
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7619
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7622
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7625
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7628
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7631
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7634
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7637
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7640
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7643
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7646
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7649
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7652
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7655
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7658
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7661
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7664
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7667
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7670
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7677
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, 0, 1, 2]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7682
+assert_return(
+  () => invoke($0, `eq`, [
+    f32x4([-1, 0, 1, 2]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7687
+assert_return(
+  () => invoke($0, `eq`, [f32x4([-1, 0, 1, 2]), i32x4([0xbf800000, 0x0, 0x1, 0x2])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7694
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, 0, 1, 2]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7699
+assert_return(
+  () => invoke($0, `ne`, [
+    f32x4([-1, 0, 1, 2]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7704
+assert_return(
+  () => invoke($0, `ne`, [f32x4([-1, 0, 1, 2]), i32x4([0xbf800000, 0x0, 0x1, 0x2])]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7711
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, 0, 1, 2]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7716
+assert_return(
+  () => invoke($0, `lt`, [
+    f32x4([-1, 0, 1, 2]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7721
+assert_return(
+  () => invoke($0, `lt`, [f32x4([-1, 0, 1, 2]), i32x4([0xbf800000, 0x0, 0x1, 0x2])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7728
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, 0, 1, 2]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7733
+assert_return(
+  () => invoke($0, `le`, [
+    f32x4([-1, 0, 1, 2]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7738
+assert_return(
+  () => invoke($0, `le`, [f32x4([-1, 0, 1, 2]), i32x4([0xbf800000, 0x0, 0x1, 0x2])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7745
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, 0, 1, 2]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7750
+assert_return(
+  () => invoke($0, `gt`, [
+    f32x4([-1, 0, 1, 2]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7755
+assert_return(
+  () => invoke($0, `gt`, [f32x4([-1, 0, 1, 2]), i32x4([0xbf800000, 0x0, 0x1, 0x2])]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7762
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, 0, 1, 2]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7767
+assert_return(
+  () => invoke($0, `ge`, [
+    f32x4([-1, 0, 1, 2]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7772
+assert_return(
+  () => invoke($0, `ge`, [f32x4([-1, 0, 1, 2]), i32x4([0xbf800000, 0x0, 0x1, 0x2])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7779
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7780
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7781
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7782
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7783
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7784
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7789
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (f4x32.eq (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7790
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (f4x32.ge (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7791
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (f4x32.gt (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7792
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (f4x32.le (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7793
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (f4x32.lt (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7794
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (f4x32.ne (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:7799
+let $1 = instantiate(`(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))
+          )
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8056
+assert_return(() => invoke($1, `eq-in-block`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8057
+assert_return(() => invoke($1, `ne-in-block`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8058
+assert_return(() => invoke($1, `lt-in-block`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8059
+assert_return(() => invoke($1, `le-in-block`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8060
+assert_return(() => invoke($1, `gt-in-block`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8061
+assert_return(() => invoke($1, `ge-in-block`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8062
+assert_return(() => invoke($1, `nested-eq`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8063
+assert_return(() => invoke($1, `nested-ne`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8064
+assert_return(() => invoke($1, `nested-lt`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8065
+assert_return(() => invoke($1, `nested-le`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8066
+assert_return(() => invoke($1, `nested-gt`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8067
+assert_return(() => invoke($1, `nested-ge`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8068
+assert_return(() => invoke($1, `as-param`, []), []);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8072
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.eq-1st-arg-empty (result v128)
+      (f32x4.eq (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8080
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.eq-arg-empty (result v128)
+      (f32x4.eq)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8088
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.ne-1st-arg-empty (result v128)
+      (f32x4.ne (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8096
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.ne-arg-empty (result v128)
+      (f32x4.ne)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8104
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.lt-1st-arg-empty (result v128)
+      (f32x4.lt (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8112
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.lt-arg-empty (result v128)
+      (f32x4.lt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8120
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.le-1st-arg-empty (result v128)
+      (f32x4.le (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8128
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.le-arg-empty (result v128)
+      (f32x4.le)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8136
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.gt-1st-arg-empty (result v128)
+      (f32x4.gt (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8144
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.gt-arg-empty (result v128)
+      (f32x4.gt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8152
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.ge-1st-arg-empty (result v128)
+      (f32x4.ge (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_cmp.wast:8160
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.ge-arg-empty (result v128)
+      (f32x4.ge)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js
new file mode 100644
index 0000000000..c0f65854cb
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_pmin_pmax.wast.js
@@ -0,0 +1,92356 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:12
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:15
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:18
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:21
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:24
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:27
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:30
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:33
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:36
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:39
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:42
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:45
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:48
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:51
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:54
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:57
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:60
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:63
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:66
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:69
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:72
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:75
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:78
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:81
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:84
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:87
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:90
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:93
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:96
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:99
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:102
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:105
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:108
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:111
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:114
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:117
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:120
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:123
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:126
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:129
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:132
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:135
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:138
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:141
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:144
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:147
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:150
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:153
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:156
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:159
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:162
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:165
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:168
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:171
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:174
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:177
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:180
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:183
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:186
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:189
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:192
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:195
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:198
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:201
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:204
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:207
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:210
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:213
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:216
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:219
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:222
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:225
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:228
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:231
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:234
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:237
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:240
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:243
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:246
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:249
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:252
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:255
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:258
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:261
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:264
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:267
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:270
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:273
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:276
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:279
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:282
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:285
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:288
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:291
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:294
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:297
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:300
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:303
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:306
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:309
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:312
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:315
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:318
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:321
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:324
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:327
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:330
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:333
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:336
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:339
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:342
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:345
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:348
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:351
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:354
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:357
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:360
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:363
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:366
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:369
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:372
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:375
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:378
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:381
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:384
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:387
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:390
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:393
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:396
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:399
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:402
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:405
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:408
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:411
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:414
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:417
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:420
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:423
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:426
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:429
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:432
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:435
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:438
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:441
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:444
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:447
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:450
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:453
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:456
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:459
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:462
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:465
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:468
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:471
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:474
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:477
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:480
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:483
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:486
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:489
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:492
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:495
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:498
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:501
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:504
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:507
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:510
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:513
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:516
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:519
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:522
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:525
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:528
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:531
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:534
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:537
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:540
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:543
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:546
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:549
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:552
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:555
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:558
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:561
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:564
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:567
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:570
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:573
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:576
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:579
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:582
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:585
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:588
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:591
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:594
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:597
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:600
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:603
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:606
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:609
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:612
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:615
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:618
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:621
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:624
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:627
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:630
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:633
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:636
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:639
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:642
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:645
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:648
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:651
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:654
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:657
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:660
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:663
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:666
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:669
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:672
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:675
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:678
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:681
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:684
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:687
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:690
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:693
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:696
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:699
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:702
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:705
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:708
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:711
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:714
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:717
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:720
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:723
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:726
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:729
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:732
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:735
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:738
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:741
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:744
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:747
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:750
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:753
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:756
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:759
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:762
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:765
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:768
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:771
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:774
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:777
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:780
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:783
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:786
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:789
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:792
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:795
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:798
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:801
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:804
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:807
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:810
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:813
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:816
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:819
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:822
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:825
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:828
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:831
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:834
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:837
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:840
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:843
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:846
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:849
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:852
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:855
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:858
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:861
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:864
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:867
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:870
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:873
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:876
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:879
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:882
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:885
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:888
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:891
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:894
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:897
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:900
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:903
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:906
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:909
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:912
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:915
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:918
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:921
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:924
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:927
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:930
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:933
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:936
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:939
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:942
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:945
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:948
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:951
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:954
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:957
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:960
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:963
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:966
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:969
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:972
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:975
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:978
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:981
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:984
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:987
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:990
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:993
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:996
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:999
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1002
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1005
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1008
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1011
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1014
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1017
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1020
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1023
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1026
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1029
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1032
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1035
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1038
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1041
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1044
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1047
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1050
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1053
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1056
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1059
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1062
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1065
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1068
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1071
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1074
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1077
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1080
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1083
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1086
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1089
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1092
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1095
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1098
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1101
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1104
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1107
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1110
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1113
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1116
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1119
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1122
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1125
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1128
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1131
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1134
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1137
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1140
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1143
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1146
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1149
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1152
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1155
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1158
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1161
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1164
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1167
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1170
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1173
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1176
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1179
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1182
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1185
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1188
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1191
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1194
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1197
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1200
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1203
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1206
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1209
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1212
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1215
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1218
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1221
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1224
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1227
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1230
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1233
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1236
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1239
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1242
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1245
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1248
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1251
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1254
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1257
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1260
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1263
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1266
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1269
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1272
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1275
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1278
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1281
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1284
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1287
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1290
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1293
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1296
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1299
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1302
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1305
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1308
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1311
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1314
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1317
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1320
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1323
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1326
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1329
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1332
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1335
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1338
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1341
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1344
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1347
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1350
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1353
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1356
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1359
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1362
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1365
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1368
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1371
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1374
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1377
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1380
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1383
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1386
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1389
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1392
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1395
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1398
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1401
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1404
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1407
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1410
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1413
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1416
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1419
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1422
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1425
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1428
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1431
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1434
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1437
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1440
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1443
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1446
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1449
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1452
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1455
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1458
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1461
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1464
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1467
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1470
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1473
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1476
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1479
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1482
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1485
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1488
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1491
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1494
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1497
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1500
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1503
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1506
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1509
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1512
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1515
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1518
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1521
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1524
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1527
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1530
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1533
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1536
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1539
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1542
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1545
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1548
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1551
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1554
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1557
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1560
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1563
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1566
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1569
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1572
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1575
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1578
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1581
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1584
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1587
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1590
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1593
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1596
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1599
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1602
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1605
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1608
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1611
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1614
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1617
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1620
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1623
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1626
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1629
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1632
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1635
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1638
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1641
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1644
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1647
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1650
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1653
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1656
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1659
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1662
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1665
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1668
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1671
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1674
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1677
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1680
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1683
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1686
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1689
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1692
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1695
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1698
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1701
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1704
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1707
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1710
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1713
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1716
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1719
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1722
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1725
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1728
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1731
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1734
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1737
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1740
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1743
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1746
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1749
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1752
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1755
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1758
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1761
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1764
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1767
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1770
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1773
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1776
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1779
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1782
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1785
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1788
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1791
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1794
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1797
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1800
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1803
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1806
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1809
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1812
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1815
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1818
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1821
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1824
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1827
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1830
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1833
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1836
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1839
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1842
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1845
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1848
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1851
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1854
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1857
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1860
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1863
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1866
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1869
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1872
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1875
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1878
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1881
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1884
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1887
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1890
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1893
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1896
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1899
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1902
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1905
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1908
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1911
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1914
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1917
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1920
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1923
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1926
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1929
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1932
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1935
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1938
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1941
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1944
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1947
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1950
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1953
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1956
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1959
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1962
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1965
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1968
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1971
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1974
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1977
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1980
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1983
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1986
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1989
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1992
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1995
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:1998
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2001
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2004
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2007
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2010
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2013
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2016
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2019
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2022
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2025
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2028
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2031
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2034
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2037
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2040
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2043
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2046
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2049
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2052
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2055
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2058
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2061
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2064
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2067
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2070
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2073
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2076
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2079
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2082
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2085
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2088
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2091
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2094
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2097
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2100
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2103
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2106
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2109
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2112
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2115
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2118
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2121
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2124
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2127
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2130
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2133
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2136
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2139
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2142
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2145
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2148
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2151
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2154
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2157
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2160
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2163
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2166
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2169
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2172
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2175
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2178
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2181
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2184
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2187
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2190
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2193
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2196
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2199
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2202
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2205
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2208
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2211
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2214
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2217
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2220
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2223
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2226
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2229
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2232
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2235
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2238
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2241
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2244
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2247
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2250
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2253
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2256
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2259
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2262
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2265
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2268
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2271
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2274
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2277
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2280
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2283
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2286
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2289
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2292
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2295
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2298
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2301
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2304
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2307
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2310
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2313
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2316
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2319
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2322
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2325
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2328
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2331
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2334
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2337
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2340
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2343
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2346
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2349
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2352
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2355
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2358
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2361
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2364
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2367
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2370
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2373
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2376
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2379
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2382
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2385
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2388
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2391
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2394
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2397
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2400
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2403
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2406
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2409
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2412
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2415
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2418
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2421
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2424
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2427
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2430
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2433
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2436
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2439
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2442
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2445
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2448
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2451
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2454
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2457
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2460
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2463
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2466
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2469
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2472
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2475
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2478
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2481
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2484
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2487
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2490
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2493
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2496
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2499
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2502
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2505
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2508
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2511
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2514
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2517
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2520
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2523
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2526
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2529
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2532
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2535
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2538
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2541
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2544
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2547
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2550
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2553
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2556
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2559
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2562
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2565
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2568
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2571
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2574
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2577
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2580
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2583
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2586
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2589
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2592
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2595
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2598
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2601
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2604
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2607
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2610
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2613
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2616
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2619
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2622
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2625
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2628
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2631
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2634
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2637
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2640
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2643
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2646
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2649
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2652
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2655
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2658
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2661
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2664
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2667
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2670
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2673
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2676
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2679
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2682
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2685
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2688
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2691
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2694
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2697
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2700
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2703
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2706
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2709
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2712
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2715
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2718
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2721
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2724
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2727
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2730
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2733
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2736
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2739
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2742
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2745
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2748
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2751
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2754
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2757
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2760
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2763
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2766
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2769
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2772
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2775
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2778
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2781
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2784
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2787
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2790
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2793
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2796
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2799
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2802
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2805
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2808
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2811
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2814
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2817
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2820
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2823
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2826
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2829
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2832
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2835
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2838
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2841
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2844
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2847
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2850
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2853
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2856
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2859
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2862
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2865
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2868
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2871
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2874
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2877
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2880
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2883
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2886
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2889
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2892
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2895
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2898
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2901
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2904
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2907
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2910
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2913
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2916
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2919
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2922
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2925
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2928
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2931
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2934
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2937
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2940
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2943
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2946
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2949
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2952
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2955
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2958
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2961
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2964
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2967
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2970
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2973
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2976
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2979
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2982
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2985
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2988
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2991
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2994
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:2997
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3000
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3003
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3006
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3009
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3012
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3015
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3018
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3021
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3024
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3027
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3030
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3033
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3036
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3039
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3042
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3045
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3048
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3051
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3054
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3057
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3060
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3063
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3066
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3069
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3072
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3075
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3078
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3081
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3084
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3087
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3090
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3093
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3096
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3099
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3102
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3105
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3108
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3111
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3114
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3117
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3120
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3123
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3126
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3129
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3132
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3135
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3138
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3141
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3144
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3147
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3150
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3153
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3156
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3159
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3162
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3165
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3168
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3171
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3174
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3177
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3180
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3183
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3186
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3189
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3192
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3195
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3198
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3201
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3204
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3207
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3210
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3213
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3216
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3219
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3222
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3225
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3228
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3231
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3234
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3237
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3240
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3243
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3246
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3249
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3252
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3255
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3258
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3261
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3264
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3267
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3270
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3273
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3276
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3279
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3282
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3285
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3288
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3291
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3294
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3297
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3300
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3303
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3306
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3309
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3312
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3315
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3318
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3321
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3324
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3327
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3330
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3333
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3336
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3339
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3342
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3345
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3348
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3351
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3354
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3357
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3360
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3363
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3366
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3369
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3372
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3375
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3378
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3381
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3384
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3387
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3390
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3393
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3396
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3399
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3402
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3405
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3408
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3411
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3414
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3417
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3420
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3423
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3426
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3429
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3432
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3435
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3438
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3441
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3444
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3447
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3450
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3453
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3456
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3459
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3462
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3465
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3468
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3471
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3474
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3477
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3480
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3483
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3486
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3489
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3492
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3495
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3498
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3501
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3504
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3507
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3510
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3513
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3516
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3519
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3522
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3525
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3528
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3531
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3534
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3537
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3540
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3543
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3546
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3549
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3552
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3555
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3558
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3561
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3564
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3567
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3570
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3573
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3576
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3579
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3582
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3585
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3588
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3591
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3594
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3597
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3600
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3603
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3606
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3609
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3612
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3615
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3618
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3621
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3624
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3627
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3630
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3633
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3636
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3639
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3642
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3645
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3648
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3651
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3654
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3657
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3660
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3663
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3666
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3669
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3672
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3675
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3678
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3681
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3684
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3687
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3690
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3693
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3696
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3699
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3702
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3705
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3708
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3711
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3714
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3717
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3720
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3723
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3726
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3729
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3732
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3735
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3738
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3741
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3744
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3747
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3750
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3753
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3756
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3759
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3762
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3765
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3768
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3771
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3774
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3777
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3780
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3783
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3786
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3789
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3792
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3795
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3798
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3801
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3804
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3807
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3810
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3813
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3816
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3819
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3822
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3825
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3828
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3831
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3834
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3837
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3840
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3843
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3846
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3849
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3852
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3855
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3858
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3861
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3864
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3867
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3870
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3873
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3876
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3879
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3882
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3885
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3888
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3891
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3894
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3897
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3900
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3903
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3906
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3909
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3912
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3915
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3918
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3921
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3924
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3927
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3930
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3933
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3936
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3939
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3942
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3945
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3948
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3951
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3954
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3957
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3960
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3963
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3966
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3969
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3972
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3975
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3978
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3981
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3984
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3987
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3990
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3993
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3996
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:3999
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4002
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4005
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4008
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4011
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4014
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4017
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4020
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4023
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4026
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4029
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4032
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4035
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4038
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4041
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4044
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4047
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4050
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4053
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4056
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4059
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4062
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4065
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4068
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4071
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4074
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4077
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4080
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4083
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4086
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4089
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4092
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4095
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4098
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4101
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4104
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4107
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4110
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4113
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4116
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4119
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4122
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4125
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4128
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4131
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4134
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4137
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4140
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4143
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4146
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4149
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4152
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4155
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4158
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4161
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4164
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4167
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4170
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4173
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4176
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4179
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4182
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4185
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4188
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4191
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4194
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4197
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4200
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4203
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4206
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4209
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4212
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4215
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4218
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4221
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4224
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4227
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4230
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4233
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4236
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4239
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4242
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4245
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4248
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4251
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4254
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4257
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4260
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4263
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4266
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4269
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4272
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4275
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4278
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4281
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4284
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4287
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4290
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4293
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4296
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4299
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4302
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4305
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4308
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4311
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4314
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4317
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4320
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4323
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4326
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4329
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4332
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4335
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4338
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4341
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4344
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4347
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4350
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4353
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4356
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4359
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4362
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4365
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4368
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4371
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4374
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4377
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4380
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4383
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4386
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4389
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4392
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4395
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4398
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4401
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4404
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4407
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4410
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4413
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4416
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4419
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4422
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4425
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4428
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4431
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4434
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4437
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4440
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4443
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4446
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4449
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4452
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4455
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4458
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4461
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4464
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4467
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4470
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4473
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4476
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4479
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4482
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4485
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4488
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4491
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4494
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4497
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4500
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4503
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4506
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4509
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4512
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4515
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4518
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4521
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4524
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4527
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4530
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4533
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4536
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4539
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4542
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4545
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4548
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4551
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4554
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4557
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4560
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4563
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4566
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4569
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4572
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4575
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4578
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4581
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4584
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4587
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4590
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4593
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4596
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4599
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4602
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4605
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4608
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4611
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4614
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4617
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4620
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4623
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4626
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4629
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4632
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4635
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4638
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4641
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4644
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4647
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4650
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4653
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4656
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4659
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4662
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4665
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4668
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4671
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4674
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4677
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4680
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4683
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4686
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4689
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4692
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4695
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4698
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4701
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4704
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4707
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4710
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4713
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4716
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4719
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4722
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4725
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4728
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4731
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4734
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4737
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4740
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4743
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4746
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4749
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4752
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4755
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4758
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4761
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4764
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4767
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4770
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4773
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4776
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4779
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4782
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4785
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4788
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4791
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4794
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4797
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4800
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4803
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4806
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4809
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4812
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4815
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4818
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4821
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4824
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4827
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4830
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4833
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4836
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4839
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4842
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4845
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4848
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4851
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4854
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4857
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4860
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4863
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4866
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4869
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4872
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4875
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4878
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4881
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4884
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4887
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4890
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4893
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4896
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4899
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4902
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4905
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4908
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4911
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4914
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4917
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4920
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4923
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4926
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4929
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4932
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4935
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4938
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4941
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4944
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4947
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4950
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4953
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4956
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4959
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4962
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4965
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4968
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4971
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4974
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4977
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4980
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4983
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4986
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4989
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4992
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4995
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:4998
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5001
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5004
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5007
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5010
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5013
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5016
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5019
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5022
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5025
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5028
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5031
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5034
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5037
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5040
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5043
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5046
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5049
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5052
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5055
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5058
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5061
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5064
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5067
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5070
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5073
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5076
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5079
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5082
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5085
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5088
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5091
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5094
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5097
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5100
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5103
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5106
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5109
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5112
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5115
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5118
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5121
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5124
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5127
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5130
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5133
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5136
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5139
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5142
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5145
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5148
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5151
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5154
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5157
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5160
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5163
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5166
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5169
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5172
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5175
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5178
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5181
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5184
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5187
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5190
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5193
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5196
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5199
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5202
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5205
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5208
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5211
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5214
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5217
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5220
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5223
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5226
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5229
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5232
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5235
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5238
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5241
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5244
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5247
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5250
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5253
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5256
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5259
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5262
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5265
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5268
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5271
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5274
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5277
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5280
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5283
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5286
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5289
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5292
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5295
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5298
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5301
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5304
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5307
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5310
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5313
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5316
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5319
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5322
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5325
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5328
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5331
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5334
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5337
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5340
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5343
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5346
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5349
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5352
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5355
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5358
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5361
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5364
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5367
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5370
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5373
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5376
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5379
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5382
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5385
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5388
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5391
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5394
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5397
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5400
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5403
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5406
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5409
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5412
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5415
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5418
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5421
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5424
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5427
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5430
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5433
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5436
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5439
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5442
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5445
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5448
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5451
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5454
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5457
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5460
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5463
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5466
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5469
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5472
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5475
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5478
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5481
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5484
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5487
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5490
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5493
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5496
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5499
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5502
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5505
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5508
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5511
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5514
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5517
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5520
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5523
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5526
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5529
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5532
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5535
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5538
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5541
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5544
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5547
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5550
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5553
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5556
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5559
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5562
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5565
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5568
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5571
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5574
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5577
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5580
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5583
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5586
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5589
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5592
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5595
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5598
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5601
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5604
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5607
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5610
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5613
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5616
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5619
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5622
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5625
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5628
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5631
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5634
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5637
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5640
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5643
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5646
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5649
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5652
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5655
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5658
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5661
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5664
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5667
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5670
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5673
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5676
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5679
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5682
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5685
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5688
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5691
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5694
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5697
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5700
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5703
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5706
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5709
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5712
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5715
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5718
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5721
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5724
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5727
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5730
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5733
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5736
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5739
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5742
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5745
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5748
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5751
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5754
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5757
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5760
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5763
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5766
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5769
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5772
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5775
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5778
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5781
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5784
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5787
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5790
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5793
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5796
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5799
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5802
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5805
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5808
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5811
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5814
+assert_return(
+  () => invoke($0, `f32x4.pmin`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5817
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0, 0, 0, 0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5820
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0, 0, 0, 0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5823
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5826
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5829
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5832
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5835
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0, 0, 0, 0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5838
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0, 0, 0, 0]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5841
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0, 0, 0, 0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5844
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0, 0, 0, 0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5847
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5850
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5853
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5856
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5859
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5862
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5865
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5868
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5871
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5874
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5877
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5880
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5883
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5886
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5889
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5892
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5895
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5898
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5901
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5904
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5907
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5910
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5913
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5916
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5919
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5922
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5925
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5928
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5931
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5934
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5937
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0, -0, -0, -0]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5940
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0, -0, -0, -0]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5943
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5946
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5949
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5952
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5955
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0, -0, -0, -0]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5958
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5961
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0, -0, -0, -0]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5964
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0, -0, -0, -0]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5967
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5970
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5973
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5976
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5979
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5982
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5985
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5988
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5991
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5994
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:5997
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6000
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6003
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6006
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6009
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6012
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6015
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6018
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6021
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6024
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6027
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6030
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6033
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6036
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6039
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6042
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6045
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6048
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6051
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6054
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6057
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6060
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6063
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6066
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6069
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6072
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6075
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6078
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6081
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6084
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6087
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6090
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6093
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6096
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6099
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6102
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6105
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6108
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6111
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6114
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6117
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6120
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6123
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6126
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6129
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6132
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6135
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6138
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6141
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6144
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6147
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6150
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6153
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6156
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6159
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6162
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6165
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6168
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6171
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6174
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6177
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6180
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6183
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6186
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6189
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6192
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6195
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6198
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6201
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6204
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6207
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6210
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6213
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6216
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6219
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6222
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6225
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6228
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6231
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6234
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6237
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6240
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6243
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6246
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6249
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6252
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6255
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6258
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6261
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6264
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6267
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6270
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6273
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6276
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6279
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6282
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6285
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6288
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6291
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6294
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6297
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6300
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6303
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6306
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6309
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6312
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6315
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6318
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6321
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6324
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6327
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6330
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6333
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6336
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6339
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6342
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6345
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6348
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6351
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6354
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6357
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6360
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6363
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6366
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6369
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6372
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6375
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6378
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6381
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6384
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6387
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6390
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6393
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6396
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6399
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6402
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6405
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6408
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6411
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6414
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6417
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6420
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6423
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6426
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6429
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6432
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6435
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6438
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6441
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6444
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6447
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6450
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6453
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6456
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6459
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6462
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6465
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6468
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6471
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6474
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6477
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6480
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6483
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6486
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6489
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6492
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6495
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6498
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6501
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6504
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6507
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6510
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6513
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6516
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6519
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6522
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6525
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6528
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6531
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6534
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6537
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6540
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6543
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6546
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6549
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6552
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6555
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6558
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6561
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6564
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([0.5, 0.5, 0.5, 0.5]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6567
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6570
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6573
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6576
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6579
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6582
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6585
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6588
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6591
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6594
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6597
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6600
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6603
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6606
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6609
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6612
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6615
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6618
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6621
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6624
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6627
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6630
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6633
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6636
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6639
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6642
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6645
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6648
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6651
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6654
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6657
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6660
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6663
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6666
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6669
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6672
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6675
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6678
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6681
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-0.5, -0.5, -0.5, -0.5]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6684
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6687
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6690
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6693
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6696
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6699
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6702
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6705
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6708
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6711
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6714
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6717
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6720
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6723
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6726
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6729
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6732
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6735
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6738
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6741
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6744
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6747
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6750
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6753
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6756
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6759
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6762
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6765
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6768
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6771
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6774
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6777
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([1, 1, 1, 1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6780
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([1, 1, 1, 1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6783
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6786
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6789
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6792
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6795
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([1, 1, 1, 1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6798
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([1, 1, 1, 1]), f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6801
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([1, 1, 1, 1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6804
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([1, 1, 1, 1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6807
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6810
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6813
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6816
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6819
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6822
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6825
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6828
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6831
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6834
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6837
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6840
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6843
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6846
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6849
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6852
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6855
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6858
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6861
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6864
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6867
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6870
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6873
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6876
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6879
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6882
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6885
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6888
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6891
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6894
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6897
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-1, -1, -1, -1]), f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6900
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-1, -1, -1, -1]), f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6903
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6906
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6909
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6912
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6915
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-1, -1, -1, -1]), f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6918
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6921
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-1, -1, -1, -1]), f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6924
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [f32x4([-1, -1, -1, -1]), f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6927
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6930
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6933
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6936
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6939
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6942
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6945
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6948
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6951
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6954
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6957
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6960
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6963
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6966
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6969
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6972
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6975
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6978
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6981
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6984
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6987
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6990
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6993
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6996
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:6999
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7002
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7005
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7008
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7011
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7014
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7017
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7020
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7023
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7026
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7029
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7032
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7035
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7038
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7041
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7044
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7047
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7050
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7053
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7056
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7059
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7062
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7065
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7068
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7071
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7074
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7077
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7080
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7083
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7086
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7089
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7092
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7095
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7098
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7101
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7104
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7107
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7110
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7113
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7116
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7119
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7122
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7125
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7128
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7131
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7134
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7137
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7140
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7143
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7146
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7149
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7152
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7155
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7158
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7161
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7164
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7167
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7170
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7173
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7176
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7179
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7182
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7185
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7188
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7191
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7194
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7197
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7200
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7203
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7206
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7209
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7212
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7215
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7218
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7221
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7224
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7227
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7230
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7233
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7236
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7239
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7242
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7245
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7248
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7251
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7254
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7257
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7260
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7263
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7266
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7269
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7272
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7275
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7278
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7281
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7284
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7287
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7290
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7293
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7296
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7299
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7302
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7305
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7308
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7311
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7314
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7317
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7320
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7323
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7326
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7329
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7332
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7335
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7338
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7341
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7344
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7347
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7350
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7353
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7356
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7359
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7362
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7365
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7368
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7371
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7374
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7377
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7380
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7383
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7386
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7389
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7392
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7395
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7398
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7401
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7404
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7407
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7410
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7413
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7416
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7419
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7422
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7425
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7428
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7431
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7434
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7437
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7440
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7443
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7446
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7449
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7452
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7455
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7458
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7461
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7464
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7467
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7470
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7473
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7476
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7479
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7482
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7485
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7488
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7491
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7494
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7497
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7500
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7503
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7506
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7509
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7512
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7515
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7518
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7521
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7524
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7527
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7530
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7533
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7536
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7539
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7542
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7545
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7548
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7551
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7554
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7557
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7560
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7563
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7566
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7569
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7572
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7575
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7578
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7581
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7584
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7587
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7590
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7593
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7596
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7599
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7602
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7605
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7608
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7611
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7614
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7617
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7620
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7623
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7626
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7629
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7632
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7635
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7638
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7641
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7644
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7647
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7650
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7653
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7656
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7659
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7662
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7665
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7668
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7671
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7674
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7677
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7680
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7683
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7686
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7689
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7692
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7695
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7698
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7701
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7704
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7707
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7710
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7713
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7716
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7719
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7722
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7725
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7728
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7731
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7734
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7737
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7740
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7743
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7746
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7749
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7752
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7755
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7758
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7761
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7764
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7767
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7770
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7773
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7776
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7779
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7782
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7785
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7788
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7791
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7794
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7797
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7800
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7803
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7806
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7809
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7812
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7815
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7818
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7821
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7824
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7827
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7830
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7833
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7836
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7839
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7842
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7845
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7848
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7851
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7854
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7857
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7860
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7863
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7866
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7869
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7872
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7875
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7878
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7881
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7884
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7887
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7890
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7893
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7896
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7899
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7902
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7905
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7908
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7911
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7914
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7917
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7920
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7923
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7926
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7929
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7932
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7935
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7938
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7941
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7944
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7947
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7950
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7953
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7956
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7959
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7962
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7965
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7968
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7971
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7974
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7977
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7980
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7983
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7986
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7989
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7992
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7995
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:7998
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8001
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8004
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8007
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8010
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8013
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8016
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8019
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8022
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8025
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8028
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8031
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8034
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8037
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8040
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8043
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8046
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8049
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8052
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8055
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8058
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8061
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8064
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8067
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8070
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8073
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8076
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8079
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8082
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8085
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8088
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8091
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8094
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8097
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8100
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8103
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8106
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8109
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8112
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8115
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8118
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8121
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8124
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8127
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8130
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8133
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8136
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8139
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8142
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8145
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8148
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8151
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8154
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8157
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8160
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8163
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8166
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8169
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8172
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8175
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8178
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8181
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8184
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8187
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8190
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8193
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8196
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8199
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8202
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8205
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8208
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8211
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8214
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8217
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8220
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8223
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8226
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8229
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8232
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8235
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8238
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8241
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8244
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8247
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8250
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8253
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8256
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8259
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8262
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8265
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8268
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8271
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8274
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8277
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8280
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8283
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8286
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8289
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8292
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8295
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8298
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8301
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8304
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8307
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8310
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8313
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8316
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8319
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8322
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8325
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8328
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8331
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8334
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8337
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8340
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8343
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8346
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8349
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8352
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8355
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8358
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8361
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8364
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8367
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8370
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8373
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8376
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8379
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8382
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8385
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8388
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8391
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8394
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8397
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8400
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8403
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8406
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8409
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8412
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8415
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8418
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8421
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8424
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8427
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8430
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8433
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8436
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8439
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8442
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8445
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8448
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8451
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8454
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8457
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8460
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8463
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8466
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8469
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8472
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8475
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8478
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8481
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8484
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8487
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8490
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8493
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8496
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8499
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8502
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8505
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8508
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8511
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8514
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8517
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8520
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8523
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8526
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8529
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8532
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8535
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8538
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8541
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8544
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8547
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8550
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8553
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8556
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8559
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8562
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8565
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8568
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8571
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8574
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8577
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8580
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8583
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8586
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8589
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8592
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8595
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8598
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8601
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8604
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8607
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8610
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8613
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8616
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8619
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8622
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8625
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8628
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8631
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8634
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8637
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8640
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8643
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8646
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8649
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8652
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8655
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8658
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8661
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8664
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8667
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8670
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8673
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8676
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8679
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8682
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8685
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8688
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8691
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8694
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8697
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8700
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8703
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8706
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8709
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8712
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8715
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8718
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8721
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8724
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8727
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8730
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8733
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8736
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8739
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8742
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8745
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8748
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8751
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8754
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8757
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8760
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8763
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8766
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8769
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8772
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8775
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8778
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8781
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8784
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8787
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8790
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8793
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8796
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8799
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8802
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8805
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8808
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8811
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8814
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8817
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8820
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8823
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8826
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8829
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8832
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8835
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8838
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8841
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8844
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8847
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8850
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8853
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8856
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8859
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8862
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8865
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8868
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8871
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8874
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8877
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8880
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8883
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8886
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8889
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8892
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8895
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8898
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8901
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8904
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8907
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8910
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8913
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8916
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8919
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8922
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8925
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8928
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8931
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8934
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8937
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8940
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8943
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8946
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8949
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8952
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8955
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8958
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8961
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8964
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8967
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8970
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8973
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8976
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8979
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8982
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8985
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8988
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8991
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8994
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:8997
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9000
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9003
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9006
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9009
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9012
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9015
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9018
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9021
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9024
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9027
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9030
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9033
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9036
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9039
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9042
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9045
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9048
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9051
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9054
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9057
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9060
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9063
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9066
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9069
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9072
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9075
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9078
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9081
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9084
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9087
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9090
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9093
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9096
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9099
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9102
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9105
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9108
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9111
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9114
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9117
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9120
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9123
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9126
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9129
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9132
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9135
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9138
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9141
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9144
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9147
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9150
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9153
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9156
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9159
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9162
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9165
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9168
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9171
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9174
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9177
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9180
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9183
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9186
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9189
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9192
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9195
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9198
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9201
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9204
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9207
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9210
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9213
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9216
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9219
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9222
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9225
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9228
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9231
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9234
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9237
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9240
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9243
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9246
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9249
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9252
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9255
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9258
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9261
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9264
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9267
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9270
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9273
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9276
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9279
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9282
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9285
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9288
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9291
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9294
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9297
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9300
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9303
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9306
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9309
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9312
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9315
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9318
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9321
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9324
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9327
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9330
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9333
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9336
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9339
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9342
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9345
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9348
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9351
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9354
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9357
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9360
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9363
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9366
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9369
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9372
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9375
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9378
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9381
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9384
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9387
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9390
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9393
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9396
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9399
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9402
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9405
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9408
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9411
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9414
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9417
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9420
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9423
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9426
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9429
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9432
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9435
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9438
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9441
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9444
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9447
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9450
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9453
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9456
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9459
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9462
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9465
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9468
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9471
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9474
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9477
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9480
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9483
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9486
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9489
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9492
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9495
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9498
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9501
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9504
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9507
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9510
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9513
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9516
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9519
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9522
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9525
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9528
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9531
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9534
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9537
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9540
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9543
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9546
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9549
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9552
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9555
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9558
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9561
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9564
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9567
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9570
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9573
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9576
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9579
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9582
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9585
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9588
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9591
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9594
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9597
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9600
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9603
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9606
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9609
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9612
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9615
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9618
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9621
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9624
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9627
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9630
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9633
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9636
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9639
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9642
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9645
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9648
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9651
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9654
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9657
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9660
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9663
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9666
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9669
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9672
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9675
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9678
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9681
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9684
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9687
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9690
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9693
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9696
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9699
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9702
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9705
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9708
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9711
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9714
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9717
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9720
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9723
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9726
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9729
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9732
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9735
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9738
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9741
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9744
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9747
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9750
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9753
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9756
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9759
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9762
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9765
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9768
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9771
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9774
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9777
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9780
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9783
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9786
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9789
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9792
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9795
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9798
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9801
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9804
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9807
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9810
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9813
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9816
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9819
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9822
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9825
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9828
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9831
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9834
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9837
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9840
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9843
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9846
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9849
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9852
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9855
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9858
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9861
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9864
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9867
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9870
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9873
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9876
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9879
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9882
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9885
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9888
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9891
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9894
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9897
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9900
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9903
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9906
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9909
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9912
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9915
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9918
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9921
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9924
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9927
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9930
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9933
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9936
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9939
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9942
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9945
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9948
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9951
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9954
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9957
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9960
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9963
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9966
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9969
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9972
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9975
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9978
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9981
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9984
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9987
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9990
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9993
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9996
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:9999
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10002
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10005
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10008
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10011
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10014
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10017
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10020
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10023
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10026
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10029
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10032
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10035
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10038
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10041
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10044
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10047
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10050
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10053
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10056
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10059
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10062
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10065
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10068
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10071
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10074
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10077
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10080
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10083
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10086
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10089
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10092
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10095
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10098
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10101
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10104
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10107
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10110
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10113
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10116
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10119
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10122
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10125
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10128
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10131
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10134
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10137
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10140
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10143
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10146
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10149
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10152
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10155
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10158
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10161
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10164
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10167
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10170
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10173
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10176
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10179
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10182
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10185
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10188
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10191
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10194
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10197
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10200
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10203
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10206
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10209
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10212
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10215
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10218
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10221
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10224
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10227
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10230
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10233
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10236
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10239
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10242
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10245
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10248
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10251
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10254
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10257
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10260
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10263
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10266
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10269
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10272
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10275
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10278
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10281
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10284
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10287
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10290
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10293
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10296
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10299
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10302
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10305
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10308
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10311
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10314
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10317
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10320
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10323
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10326
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10329
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10332
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10335
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10338
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10341
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10344
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10347
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10350
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10353
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10356
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10359
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10362
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10365
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10368
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10371
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10374
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10377
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10380
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10383
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10386
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10389
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10392
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10395
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10398
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10401
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10404
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10407
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10410
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10413
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10416
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10419
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10422
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10425
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10428
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10431
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10434
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10437
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10440
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10443
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10446
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10449
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10452
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10455
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10458
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10461
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10464
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10467
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10470
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10473
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10476
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10479
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10482
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10485
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10488
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10491
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10494
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10497
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10500
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10503
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10506
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10509
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10512
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10515
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10518
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10521
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10524
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10527
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10530
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10533
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10536
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10539
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10542
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10545
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10548
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10551
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10554
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10557
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10560
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10563
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10566
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10569
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10572
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10575
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10578
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10581
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10584
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10587
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10590
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10593
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10596
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10599
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10602
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10605
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10608
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10611
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10614
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10617
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10620
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10623
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10626
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10629
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10632
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10635
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10638
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10641
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10644
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10647
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10650
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10653
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10656
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10659
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10662
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10665
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10668
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10671
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10674
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10677
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10680
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10683
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10686
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10689
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10692
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10695
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10698
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10701
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10704
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10707
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10710
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10713
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10716
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10719
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10722
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10725
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10728
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10731
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10734
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10737
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10740
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10743
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10746
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10749
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10752
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10755
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10758
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10761
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10764
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10767
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10770
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10773
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10776
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10779
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10782
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10785
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10788
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10791
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10794
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10797
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10800
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10803
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10806
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10809
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10812
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10815
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10818
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10821
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10824
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10827
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10830
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10833
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10836
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10839
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10842
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10845
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10848
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10851
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10854
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10857
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10860
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10863
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10866
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10869
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10872
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10875
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10878
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10881
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10884
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10887
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10890
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10893
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10896
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10899
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10902
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10905
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10908
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10911
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10914
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10917
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10920
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10923
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10926
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10929
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10932
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10935
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10938
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10941
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10944
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10947
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10950
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10953
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10956
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10959
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10962
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10965
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10968
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10971
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10974
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10977
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10980
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10983
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10986
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10989
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10992
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10995
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:10998
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11001
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11004
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11007
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11010
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11013
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11016
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11019
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11022
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11025
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11028
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11031
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11034
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11037
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11040
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11043
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11046
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11049
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11052
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11055
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11058
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11061
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11064
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11067
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11070
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11073
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11076
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11079
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11082
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11085
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11088
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11091
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11094
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11097
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11100
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11103
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11106
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11109
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11112
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11115
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11118
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11121
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11124
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11127
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11130
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11133
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11136
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11139
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11142
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+      bytes("f32", [0x0, 0x0, 0xa0, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11145
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11148
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11151
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11154
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11157
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11160
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11163
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11166
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11169
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11172
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11175
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11178
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11181
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11184
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11187
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11190
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11193
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11196
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11199
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11202
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11205
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11208
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11211
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11214
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11217
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11220
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11223
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11226
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11229
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11232
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11235
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11238
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11241
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11244
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11247
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11250
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11253
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11256
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11259
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11262
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11265
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11268
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11271
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11274
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11277
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11280
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11283
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11286
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11289
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11292
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11295
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11298
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11301
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11304
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11307
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11310
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11313
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11316
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11319
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11322
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11325
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11328
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11331
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11334
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11337
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11340
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11343
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11346
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11349
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11352
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11355
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11358
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11361
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11364
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11367
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11370
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11373
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11376
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11379
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11382
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11385
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11388
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11391
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11394
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11397
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11400
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11403
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11406
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11409
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11412
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11415
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11418
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11421
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11424
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11427
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11430
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11433
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11436
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11439
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11442
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11445
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11448
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11451
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11454
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11457
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11460
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11463
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11466
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11469
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11472
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11475
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11478
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11481
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11484
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11487
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11490
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11493
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11496
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11499
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11502
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11505
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11508
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0, -0, -0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11511
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+      value("f32", 0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11514
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+      value("f32", -0.000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11517
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+      value("f32", 0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11520
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+      value("f32", -0.000000000000000000000000000000000000011754944),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11523
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([0.5, 0.5, 0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+      value("f32", 0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11526
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-0.5, -0.5, -0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+      value("f32", -0.5),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11529
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([1, 1, 1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11532
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-1, -1, -1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11535
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+      value("f32", 6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11538
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+      value("f32", -6.2831855),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11541
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11544
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11547
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11550
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11553
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11556
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11559
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11562
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11565
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11568
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11571
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11574
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11577
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11580
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11583
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11586
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+      value("f32", 0.000000000012345679),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11589
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11592
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11595
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11598
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11601
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11604
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11607
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11610
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11613
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11616
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11619
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11622
+assert_return(
+  () => invoke($0, `f32x4.pmax`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11629
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11630
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11631
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11632
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11633
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11634
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11635
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11636
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11639
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.pmin (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11640
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.pmax (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11644
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.pmin-1st-arg-empty (result v128)
+      (f32x4.pmin (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11652
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.pmin-arg-empty (result v128)
+      (f32x4.pmin)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11660
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.pmax-1st-arg-empty (result v128)
+      (f32x4.pmax (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_pmin_pmax.wast:11668
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.pmax-arg-empty (result v128)
+      (f32x4.pmax)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js
new file mode 100644
index 0000000000..cd67d7ca22
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f32x4_rounding.wast.js
@@ -0,0 +1,3432 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f32x4_rounding.wast
+
+// ./test/core/simd/simd_f32x4_rounding.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:11
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:13
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:15
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:17
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:19
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:21
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:23
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:25
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:27
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:29
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:31
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855])]),
+  [
+    new F32x4Pattern(
+      value("f32", 7),
+      value("f32", 7),
+      value("f32", 7),
+      value("f32", 7),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:33
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:35
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:37
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:39
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:41
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:43
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:45
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:47
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:49
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:51
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:53
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:55
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:57
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:59
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:61
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:63
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:65
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:67
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:69
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:71
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:73
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:75
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:77
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:79
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:81
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:83
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:85
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:87
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:89
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:91
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:93
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:95
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:97
+assert_return(
+  () => invoke($0, `f32x4.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:99
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:101
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:103
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:105
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:107
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:109
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:111
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:113
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:115
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:117
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:119
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855])]),
+  [
+    new F32x4Pattern(
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:121
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -7),
+      value("f32", -7),
+      value("f32", -7),
+      value("f32", -7),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:123
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:125
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:127
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:129
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:131
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:133
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:135
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:137
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:139
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:141
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:143
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:145
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:147
+assert_return(
+  () => invoke($0, `f32x4.floor`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:149
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:151
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:153
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:155
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:157
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:159
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:161
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:163
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:165
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:167
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:169
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:171
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:173
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:175
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:177
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:179
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:181
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:183
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:185
+assert_return(
+  () => invoke($0, `f32x4.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:187
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:189
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:191
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:193
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:195
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:197
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:199
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:201
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:203
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:205
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:207
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855])]),
+  [
+    new F32x4Pattern(
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:209
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:211
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:213
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:215
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:217
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([-Infinity, -Infinity, -Infinity, -Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:219
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:221
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:223
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:225
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:227
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:229
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:231
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:233
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:235
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [f32x4([123456790, 123456790, 123456790, 123456790])]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:237
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:239
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:241
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:243
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:245
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:247
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:249
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:251
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:253
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:255
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:257
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:259
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:261
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:263
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:265
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:267
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:269
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:271
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:273
+assert_return(
+  () => invoke($0, `f32x4.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:275
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([0, 0, 0, 0])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:277
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([-0, -0, -0, -0])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:279
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:281
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:283
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:285
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:287
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:289
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [
+    new F32x4Pattern(
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+      value("f32", -0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:291
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([1, 1, 1, 1])]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:293
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([-1, -1, -1, -1])]),
+  [
+    new F32x4Pattern(
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+      value("f32", -1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:295
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+      value("f32", 6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:297
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+      value("f32", -6),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:299
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:301
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:303
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [f32x4([Infinity, Infinity, Infinity, Infinity])]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:305
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:307
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:309
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:311
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:313
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:315
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:317
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:319
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:321
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:323
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:325
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:327
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+      1234567900000000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:329
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+      0.000000000012345679,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:331
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:333
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:335
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:337
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:339
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:341
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:343
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:345
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:347
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([81985530000000000, 81985530000000000, 81985530000000000, 81985530000000000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:349
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:351
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+      42984030000000000000000,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:353
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    f32x4([156374990000, 156374990000, 156374990000, 156374990000]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:355
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:357
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+      `canonical_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:359
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+      0x0,
+      0x0,
+      0xa0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:361
+assert_return(
+  () => invoke($0, `f32x4.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+      0x0,
+      0x0,
+      0xa0,
+      0xff,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+      `arithmetic_nan`,
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:367
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:368
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:369
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:370
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:371
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:372
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:373
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:374
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:375
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:376
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:377
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:378
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:379
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:380
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:381
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:382
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:385
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.ceil (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:386
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.floor (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:387
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.trunc (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:388
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.nearest (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:392
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.ceil-arg-empty (result v128)
+      (f32x4.ceil)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:400
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.floor-arg-empty (result v128)
+      (f32x4.floor)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:408
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.trunc-arg-empty (result v128)
+      (f32x4.trunc)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f32x4_rounding.wast:416
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.nearest-arg-empty (result v128)
+      (f32x4.nearest)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js
new file mode 100644
index 0000000000..72409ad8e9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2.wast.js
@@ -0,0 +1,13218 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f64x2.wast
+
+// ./test/core/simd/simd_f64x2.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2.wast:50
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_0`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:51
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_1`, []),
+  [new F64x2Pattern(value("f64", 1), value("f64", -3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:52
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_2`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:53
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_3`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:55
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_4`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:56
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_5`, []),
+  [new F64x2Pattern(value("f64", 1), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:57
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_6`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:58
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_7`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:59
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_9`, [f64x2([0, 2])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:61
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_10`, [f64x2([1, 3])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", -3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:63
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_11`, [f64x2([0, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:65
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_12`, [f64x2([2, 3])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:67
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_13`, [f64x2([0, 2])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:69
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_14`, [f64x2([1, 2147483648])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:71
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_15`, [f64x2([0, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:73
+assert_return(
+  () => invoke($0, `f64x2.min_with_const_16`, [f64x2([2, 2147483648])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:76
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_18`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:77
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_19`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:78
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_20`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:79
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_21`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:81
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_22`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:82
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_23`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:83
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_24`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:84
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_25`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:85
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_27`, [f64x2([0, 2])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:87
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_28`, [f64x2([1, 3])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:89
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_29`, [f64x2([0, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:91
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_30`, [f64x2([2, 3])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:93
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_31`, [f64x2([0, 2])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:95
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_32`, [f64x2([1, 2147483648])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:97
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_33`, [f64x2([0, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:99
+assert_return(
+  () => invoke($0, `f64x2.max_with_const_34`, [f64x2([2, 2147483648])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2147483648))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:102
+assert_return(
+  () => invoke($0, `f64x2.abs_with_const_35`, []),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:103
+assert_return(
+  () => invoke($0, `f64x2.abs_with_const_36`, []),
+  [new F64x2Pattern(value("f64", 2), value("f64", 3))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:107
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    f64x2([0, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:115
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:123
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x3f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:131
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    f64x2([0, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:139
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:147
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x3f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:155
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:158
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:161
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:164
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:167
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:170
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:173
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:176
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:179
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:182
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:185
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:188
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:191
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:194
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:197
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:200
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:203
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:206
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:209
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:212
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:215
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:218
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:221
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:224
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:227
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:230
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:233
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:236
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:239
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:242
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:245
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:248
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:251
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:254
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:257
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:260
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:263
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:266
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:269
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:272
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:275
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:278
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:281
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:284
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:287
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:290
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:293
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:296
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:299
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:302
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:305
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:308
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:311
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:314
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:317
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:320
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:323
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:326
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:329
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:332
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:335
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:338
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:341
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:344
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:347
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:350
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:353
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:356
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:359
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:362
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:365
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:368
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:371
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:374
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:377
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:380
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:383
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:386
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:389
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:392
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:395
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:398
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:401
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:404
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:407
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:410
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:413
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:416
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:419
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:422
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:425
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:428
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:431
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:434
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:437
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:440
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:443
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:446
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:449
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:452
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:455
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:458
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:461
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:464
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:467
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:470
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:473
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:476
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:479
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:482
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:485
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:488
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:491
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:494
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:497
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:500
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:503
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:506
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:509
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:512
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:515
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:518
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:521
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:524
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:527
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:530
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:533
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:536
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:539
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:542
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:545
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:548
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:551
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:554
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:557
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:560
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:563
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:566
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:569
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:572
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:575
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:578
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:581
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:584
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:587
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:590
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:593
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:596
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:599
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:602
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:605
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:608
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:611
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:614
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:617
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:620
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:623
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:626
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:629
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:632
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:635
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:638
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:641
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:644
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:647
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:650
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:653
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:656
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:659
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:662
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:665
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:668
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:671
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:674
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:677
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:680
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:683
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:686
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:689
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:692
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:695
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:698
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:701
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:704
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:707
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:710
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:713
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:716
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:719
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:722
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:725
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:728
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:731
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:734
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:737
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:740
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:743
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:746
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:749
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:752
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:755
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:758
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:761
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:764
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:767
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:770
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:773
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:776
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:779
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:782
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:785
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:788
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:791
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:794
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:797
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:800
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:803
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:806
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:809
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:812
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:815
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:818
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:821
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:824
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:827
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:830
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:833
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:836
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:839
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:842
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:845
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:848
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:851
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:854
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:857
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:860
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:863
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:866
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:869
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:872
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:875
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:878
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:881
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:884
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:887
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:890
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:893
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:896
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:899
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:902
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:905
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:908
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:911
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:914
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:917
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:920
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:923
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:926
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:929
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:932
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:935
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:938
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:941
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:944
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:947
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:950
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:953
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:956
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:959
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:962
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:965
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:968
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:971
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:974
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:977
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:980
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:983
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:986
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:989
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:992
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:995
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:998
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1001
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1004
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1007
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1010
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1013
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1016
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1019
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1022
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1025
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1028
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1031
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1034
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1037
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1040
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1043
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1046
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1049
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1052
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1055
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1058
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1061
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1064
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1067
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1070
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1073
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1076
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1079
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1082
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1085
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1088
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1091
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1094
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1097
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1100
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1103
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1106
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1109
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1112
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1115
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1118
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1121
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1124
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1127
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1130
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1133
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1136
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1139
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1142
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1145
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1148
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1151
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1154
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1157
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1160
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1163
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1166
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1169
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1172
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1175
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1178
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1181
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1184
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1187
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1190
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1193
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1196
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1199
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1202
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1205
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1208
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1211
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1214
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1217
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1220
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1223
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1226
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1229
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1232
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1235
+assert_return(
+  () => invoke($0, `f64x2.min`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1238
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1241
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1244
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1247
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1250
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1253
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1256
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1259
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1262
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1265
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1268
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1271
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1274
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1277
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1280
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1283
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1286
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1289
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1292
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1295
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1298
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1301
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1304
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1307
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1310
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1313
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1316
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1319
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1322
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1325
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1328
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1331
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1334
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1337
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1340
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1343
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1346
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1349
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1352
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1355
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1358
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1361
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1364
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1367
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1370
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1373
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1376
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1379
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1382
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1385
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1388
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1391
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1394
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1397
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1400
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1403
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1406
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1409
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1412
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1415
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1418
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1421
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1424
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1427
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1430
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1433
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1436
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1439
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1442
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1445
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1448
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1451
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1454
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1457
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1460
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1463
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1466
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1469
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1472
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1475
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1478
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1481
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1484
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1487
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1490
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1493
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1496
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1499
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1502
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1505
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1508
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1511
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1514
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1517
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1520
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1523
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1526
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1529
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1532
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1535
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1538
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1541
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1544
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1547
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1550
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1553
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1556
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1559
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1562
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1565
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1568
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1571
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1574
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1577
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1580
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1583
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1586
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1589
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1592
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1595
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1598
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1601
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1604
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1607
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1610
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1613
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1616
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1619
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1622
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1625
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1628
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1631
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1634
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1637
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1640
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1643
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1646
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1649
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1652
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1655
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1658
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1661
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1664
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1667
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1670
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1673
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1676
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1679
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1682
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1685
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1688
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1691
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1694
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1697
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1700
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1703
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1706
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1709
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1712
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1715
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1718
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1721
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1724
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1727
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1730
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1733
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1736
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1739
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1742
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1745
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1748
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1751
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1754
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1757
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1760
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1763
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1766
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1769
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1772
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1775
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1778
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1781
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1784
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1787
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1790
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1793
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1796
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1799
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1802
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1805
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1808
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1811
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1814
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1817
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1820
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1823
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1826
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1829
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1832
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1835
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1838
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1841
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1844
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1847
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1850
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1853
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1856
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1859
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1862
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1865
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1868
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1871
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1874
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1877
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1880
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1883
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1886
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1889
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1892
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1895
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1898
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1901
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1904
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1907
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1910
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1913
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1916
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1919
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1922
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1925
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1928
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1931
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1934
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1937
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1940
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1943
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1946
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1949
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1952
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1955
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1958
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1961
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1964
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1967
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1970
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1973
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1976
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1979
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1982
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1985
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1988
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1991
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1994
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:1997
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2000
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2003
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2006
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2009
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2012
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2015
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2018
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2021
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2024
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2027
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2030
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2033
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2036
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2039
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2042
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2045
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2048
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2051
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2054
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2057
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2060
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2063
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2066
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2069
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2072
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2075
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2078
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2081
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2084
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2087
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2090
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2093
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2096
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2099
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2102
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2105
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2108
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2111
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2114
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2117
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2120
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2123
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2126
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2129
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2132
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2135
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2138
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2141
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2144
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2147
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2150
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2153
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2156
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2159
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2162
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2165
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2168
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2171
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2174
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2177
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2180
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2183
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2186
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2189
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2192
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2195
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2198
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2201
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2204
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2207
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2210
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2213
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2216
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2219
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2222
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2225
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2228
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2231
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2234
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2237
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2240
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2243
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2246
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2249
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2252
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2255
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2258
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2261
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2264
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2267
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2270
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2273
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2276
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2279
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2282
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2285
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2288
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2291
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2294
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2297
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2300
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2303
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2306
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2309
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2312
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2315
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2318
+assert_return(
+  () => invoke($0, `f64x2.max`, [
+    f64x2([-1234567890123456800, -1234567890123456800]),
+    f64x2([-1234567890123456800, -1234567890123456800]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456800),
+      value("f64", -1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2323
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([0, 0]), f64x2([0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2326
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, 0]), f64x2([0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2329
+assert_return(
+  () => invoke($0, `f64x2.min`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2332
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([0, 0]), f64x2([0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2335
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, 0]), f64x2([0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2338
+assert_return(
+  () => invoke($0, `f64x2.max`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2343
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2345
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2347
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2349
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2351
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2353
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2355
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2357
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2359
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2361
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2363
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2365
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2367
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2369
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2371
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2373
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2375
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+      value("f64", 123456789012345690000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2377
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000012345678901234569),
+      value("f64", 0.000000000000000000012345678901234569),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2379
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2381
+assert_return(
+  () => invoke($0, `f64x2.abs`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12345678900000000000000000000000000000000000000),
+      value("f64", 12345678900000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2383
+assert_return(
+  () => invoke($0, `f64x2.abs`, [f64x2([-1234567890123456800, -1234567890123456800])]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456800),
+      value("f64", 1234567890123456800),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2387
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.abs (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2388
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2389
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2393
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.abs-arg-empty (result v128)
+      (f64x2.abs)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2401
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.min-1st-arg-empty (result v128)
+      (f64x2.min (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2409
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.min-arg-empty (result v128)
+      (f64x2.min)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2417
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.max-1st-arg-empty (result v128)
+      (f64x2.max (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2425
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.max-arg-empty (result v128)
+      (f64x2.max)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2.wast:2435
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2.wast:2446
+assert_return(
+  () => invoke($1, `max-min`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.25, 0.25]),
+    f64x2([0.125, 0.125]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.25), value("f64", 0.25))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2450
+assert_return(
+  () => invoke($1, `min-max`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.25, 0.25]),
+    f64x2([0.125, 0.125]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.125), value("f64", 0.125))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2454
+assert_return(
+  () => invoke($1, `max-abs`, [f64x2([-1.125, -1.125]), f64x2([0.125, 0.125])]),
+  [new F64x2Pattern(value("f64", 1.125), value("f64", 1.125))],
+);
+
+// ./test/core/simd/simd_f64x2.wast:2457
+assert_return(
+  () => invoke($1, `min-abs`, [f64x2([-1.125, -1.125]), f64x2([0.125, 0.125])]),
+  [new F64x2Pattern(value("f64", 0.125), value("f64", 0.125))],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js
new file mode 100644
index 0000000000..ea798af4ad
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_arith.wast.js
@@ -0,0 +1,32018 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f64x2_arith.wast
+
+// ./test/core/simd/simd_f64x2_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2_arith.wast:13
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:16
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:19
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:22
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:25
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:28
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:31
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:34
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:37
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:40
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:43
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:46
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:49
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:52
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:55
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:58
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:61
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:64
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:67
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:70
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:73
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:76
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:79
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:82
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:85
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:88
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:91
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:94
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:97
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:100
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:103
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:106
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:109
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:112
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:115
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:118
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:121
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:124
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:127
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:130
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:133
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:136
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:139
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:142
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:145
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:148
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:151
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:154
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:157
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:160
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:163
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:166
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:169
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:172
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:175
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:178
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:181
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:184
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:187
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:190
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:193
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:196
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:199
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:202
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:205
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:208
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:211
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:214
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:217
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:220
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:223
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1.5), value("f64", 1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:226
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:229
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.783185307179586),
+      value("f64", 6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:232
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.783185307179586),
+      value("f64", -5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:235
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:238
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:241
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:244
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:247
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:250
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:253
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:256
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:259
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:262
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:265
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:268
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:271
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:274
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1.5), value("f64", -1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:277
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.783185307179586),
+      value("f64", 5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:280
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.783185307179586),
+      value("f64", -6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:283
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:286
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:289
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:292
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:295
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:298
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:301
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:304
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:307
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:310
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:313
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 1.5), value("f64", 1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:316
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:319
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:322
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:325
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 7.283185307179586),
+      value("f64", 7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:328
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.283185307179586),
+      value("f64", -5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:331
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:334
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:337
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:340
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:343
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:346
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:349
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:352
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:355
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:358
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:361
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:364
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -1.5), value("f64", -1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:367
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:370
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -2), value("f64", -2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:373
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.283185307179586),
+      value("f64", 5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:376
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -7.283185307179586),
+      value("f64", -7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:379
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:382
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:385
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:388
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:391
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:394
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:397
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:400
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:403
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:406
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:409
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.783185307179586),
+      value("f64", 6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:412
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.783185307179586),
+      value("f64", 5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:415
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 7.283185307179586),
+      value("f64", 7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:418
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.283185307179586),
+      value("f64", 5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:421
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12.566370614359172),
+      value("f64", 12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:424
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:427
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:430
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:433
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:436
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:439
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:442
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:445
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:448
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:451
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:454
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:457
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.783185307179586),
+      value("f64", -5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:460
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.783185307179586),
+      value("f64", -6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:463
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.283185307179586),
+      value("f64", -5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:466
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -7.283185307179586),
+      value("f64", -7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:469
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:472
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -12.566370614359172),
+      value("f64", -12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:475
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:478
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:481
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:484
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:487
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:490
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:493
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:496
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:499
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:502
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:505
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:508
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:511
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:514
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:517
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:520
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:523
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:526
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:529
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:532
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:535
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:538
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:541
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:544
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:547
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:550
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:553
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:556
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:559
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:562
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:565
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:568
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:571
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:574
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:577
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:580
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:583
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:586
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:589
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:592
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:595
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:598
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:601
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:604
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:607
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:610
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:613
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:616
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:619
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:622
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:625
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:628
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:631
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:634
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:637
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:640
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:643
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:646
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:649
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:652
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:655
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:658
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:661
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:664
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:667
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:670
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:673
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:676
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:679
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:682
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:685
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:688
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:691
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:694
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:697
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:700
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:703
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:706
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:709
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:712
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:715
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:718
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:721
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:724
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:727
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:730
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:733
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:736
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:739
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:742
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:745
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:748
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:751
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:754
+assert_return(
+  () => invoke($0, `f64x2.add`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:757
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:760
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:763
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:766
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:769
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:772
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:775
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:778
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:781
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:784
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:787
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:790
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:793
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:796
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:799
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:802
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:805
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:808
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:811
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:814
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:817
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:820
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:823
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:826
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:829
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:832
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:835
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:838
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:841
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:844
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:847
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:850
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:853
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:856
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:859
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:862
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:865
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:868
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:871
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:874
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:877
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:880
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:883
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:886
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:889
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:892
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:895
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:898
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:901
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:904
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:907
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:910
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:913
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:916
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:919
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:922
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:925
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:928
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:931
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:934
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:937
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:940
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:943
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:946
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:949
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:952
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:955
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:958
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:961
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:964
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:967
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:970
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:973
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:976
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:979
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:982
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:985
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:988
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:991
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:994
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:997
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1000
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1003
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1006
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1009
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1012
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1015
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1018
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1021
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1024
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1027
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1030
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1033
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1036
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1039
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1042
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1045
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1048
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1051
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1054
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1057
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1060
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1063
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1066
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1069
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1072
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1075
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1078
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1081
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1084
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1087
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1090
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1093
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1096
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1099
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1102
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1105
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1108
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1111
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1114
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1117
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1120
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1123
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1126
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1129
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1132
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1135
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1138
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1141
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1144
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1147
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1150
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1153
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1156
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1159
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1162
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1165
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1168
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1171
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1174
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1177
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1180
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1183
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1186
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1189
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1192
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1195
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1198
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1201
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1204
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1207
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1210
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1213
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 246913578), value("f64", 246913578))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1216
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2469135780000000000000000000),
+      value("f64", 2469135780000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1219
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2469135780000000000000000000),
+      value("f64", 2469135780000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1222
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000246913578),
+      value("f64", 0.0000000000246913578),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1225
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 246913578), value("f64", 246913578))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1228
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2469135780000000000000000000),
+      value("f64", 2469135780000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1231
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2469135780000000000000000000),
+      value("f64", 2469135780000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1234
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000246913578),
+      value("f64", 0.0000000000246913578),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1237
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 246913578.02469134),
+      value("f64", 246913578.02469134),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1240
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2469135780246913700000000000),
+      value("f64", 2469135780246913700000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1243
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2469135780246913700000000000),
+      value("f64", 2469135780246913700000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1246
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000024691357802469137),
+      value("f64", 0.000000000024691357802469137),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1249
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2750977865078623000000000),
+      value("f64", 2750977865078623000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1252
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1442304682926341000000000000000),
+      value("f64", 1442304682926341000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1255
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1442304682926341000000000000000),
+      value("f64", 1442304682926341000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1258
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5247073869855161000),
+      value("f64", 5247073869855161000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1261
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2750977865078623000000000),
+      value("f64", 2750977865078623000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1264
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1442304682926341000000000000000),
+      value("f64", 1442304682926341000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1267
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1442304682926341000000000000000),
+      value("f64", 1442304682926341000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1270
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5247073869855161000),
+      value("f64", 5247073869855161000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1273
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2750977865078623000000000),
+      value("f64", 2750977865078623000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1276
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1442304682926341000000000000000),
+      value("f64", 1442304682926341000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1279
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1442304682926341000000000000000),
+      value("f64", 1442304682926341000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1282
+assert_return(
+  () => invoke($0, `f64x2.add`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5247073869855161000),
+      value("f64", 5247073869855161000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1285
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1288
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1291
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1294
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1297
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1300
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1303
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1306
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1309
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1312
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1315
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1318
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1321
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1324
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1327
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1330
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1333
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1336
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1339
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1342
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1345
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1348
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1351
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1354
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1357
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1360
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1363
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1366
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1369
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1372
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1375
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1378
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1381
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1384
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1387
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1390
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1393
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1396
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1399
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1402
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1405
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1408
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1411
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1414
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1417
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1420
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1423
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1426
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1429
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1432
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1435
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1438
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1441
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1444
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1447
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1450
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1453
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1456
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1459
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1462
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1465
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1468
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1471
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1474
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1477
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1480
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1483
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1486
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1489
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1492
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1495
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1498
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1.5), value("f64", 1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1501
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.783185307179586),
+      value("f64", -5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1504
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.783185307179586),
+      value("f64", 6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1507
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1510
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1513
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1516
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1519
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1522
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1525
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1528
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1531
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1534
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1537
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1540
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1543
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1.5), value("f64", -1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1546
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1549
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.783185307179586),
+      value("f64", -6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1552
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.783185307179586),
+      value("f64", 5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1555
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1558
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1561
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1564
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1567
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1570
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1573
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1576
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1579
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1582
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1585
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1588
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 1.5), value("f64", 1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1591
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1594
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1597
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.283185307179586),
+      value("f64", -5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1600
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 7.283185307179586),
+      value("f64", 7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1603
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1606
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1609
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1612
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1615
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1618
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1621
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1624
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1627
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1630
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1633
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -1.5), value("f64", -1.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1636
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1639
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -2), value("f64", -2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1642
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1645
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -7.283185307179586),
+      value("f64", -7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1648
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.283185307179586),
+      value("f64", 5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1651
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1654
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1657
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1660
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1663
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1666
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1669
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1672
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1675
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1678
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1681
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.783185307179586),
+      value("f64", 5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1684
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.783185307179586),
+      value("f64", 6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1687
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 5.283185307179586),
+      value("f64", 5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1690
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 7.283185307179586),
+      value("f64", 7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1693
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1696
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12.566370614359172),
+      value("f64", 12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1699
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1702
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1705
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1708
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1711
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1714
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1717
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1720
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1723
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1726
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1729
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.783185307179586),
+      value("f64", -6.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1732
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.783185307179586),
+      value("f64", -5.783185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1735
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -7.283185307179586),
+      value("f64", -7.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1738
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -5.283185307179586),
+      value("f64", -5.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1741
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -12.566370614359172),
+      value("f64", -12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1744
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1747
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1750
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1753
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1756
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1759
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1762
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1765
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1768
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1771
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1774
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1777
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1780
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1783
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1786
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1789
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1792
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1795
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1798
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1801
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1804
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1807
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1810
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1813
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1816
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1819
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1822
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1825
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1828
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1831
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1834
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1837
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1840
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1843
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1846
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1849
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1852
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1855
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1858
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1861
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1864
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1867
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1870
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1873
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1876
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1879
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1882
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1885
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1888
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1891
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1894
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1897
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1900
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1903
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1906
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1909
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1912
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1915
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1918
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507202),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1921
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1924
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1927
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1930
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1933
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1936
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1939
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1942
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1945
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1948
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1951
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1954
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1957
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1960
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1963
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1966
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1969
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1972
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1975
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1978
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1981
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1984
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1987
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1990
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1993
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1996
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:1999
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2002
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2005
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2008
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2011
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2014
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2017
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2020
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2023
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2026
+assert_return(
+  () => invoke($0, `f64x2.sub`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2029
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2032
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2035
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2038
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2041
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2044
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2047
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2050
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2053
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2056
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2059
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2062
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2065
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2068
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2071
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2074
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2077
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2080
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2083
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2086
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2089
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2092
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2095
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2098
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2101
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2104
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2107
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2110
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2113
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2116
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2119
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2122
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2125
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2128
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2131
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2134
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2137
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2140
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2143
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2146
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2149
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2152
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2155
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2158
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2161
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2164
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2167
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2170
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2173
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2176
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2179
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2182
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2185
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2188
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2191
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2194
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2197
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2200
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2203
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2206
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2209
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2212
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2215
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2218
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2221
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2224
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2227
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2230
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2233
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2236
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2239
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2242
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2245
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2248
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2251
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2254
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2257
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2260
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2263
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2266
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2269
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2272
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2275
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2278
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2281
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2284
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2287
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2290
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2293
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2296
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2299
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2302
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2305
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2308
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2311
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2314
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2317
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2320
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2323
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2326
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2329
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2332
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2335
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2338
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2341
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2344
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2347
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2350
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2353
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2356
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2359
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2362
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2365
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2368
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2371
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2374
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2377
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2380
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2383
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2386
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2389
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2392
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2395
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2398
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2401
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2404
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2407
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2410
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2413
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2416
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2419
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2422
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2425
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2428
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2431
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2434
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2437
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2440
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2443
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2446
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2449
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2452
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2455
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2458
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2461
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2464
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2467
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2470
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2473
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2476
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2479
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2482
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2485
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2488
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2491
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2494
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2497
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2500
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2503
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2506
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2509
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2512
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2515
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2518
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2521
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2524
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2527
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2530
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2533
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2536
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2539
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2542
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2545
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2548
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2551
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2554
+assert_return(
+  () => invoke($0, `f64x2.sub`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2557
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2560
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2563
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2566
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2569
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2572
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2575
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2578
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2581
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2584
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2587
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2590
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2593
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2596
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2599
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2602
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2605
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2608
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2611
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2614
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2617
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2620
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2623
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2626
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2629
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2632
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2635
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2638
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2641
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2644
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2647
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2650
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2653
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2656
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2659
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2662
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2665
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2668
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2671
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2674
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2677
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2680
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2683
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.9999999999999996),
+      value("f64", 3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2686
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.9999999999999996),
+      value("f64", -3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2689
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2692
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2695
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2698
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2701
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2704
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2707
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2710
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2713
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2716
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2719
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2722
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2725
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2728
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2731
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.9999999999999996),
+      value("f64", -3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2734
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.9999999999999996),
+      value("f64", 3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2737
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2740
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2743
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2746
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2749
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2752
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2755
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2758
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2761
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.25), value("f64", 0.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2764
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.25), value("f64", -0.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2767
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2770
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2773
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.141592653589793),
+      value("f64", 3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2776
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.141592653589793),
+      value("f64", -3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2779
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2782
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2785
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2788
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2791
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2794
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2797
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2800
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2803
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2806
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011125369292536007),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2809
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.25), value("f64", -0.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2812
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.25), value("f64", 0.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2815
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2818
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2821
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.141592653589793),
+      value("f64", -3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2824
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.141592653589793),
+      value("f64", 3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2827
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2830
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2833
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2836
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2839
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2842
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2845
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2848
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2851
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2854
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2857
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2860
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2863
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2866
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2869
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2872
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2875
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2878
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2881
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2884
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2887
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2890
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2893
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2896
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2899
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2902
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2905
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2908
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2911
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2914
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2917
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2920
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2923
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2926
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2929
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2932
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2935
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2938
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2941
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2944
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2947
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2950
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2953
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.141592653589793),
+      value("f64", 3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2956
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.141592653589793),
+      value("f64", -3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2959
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2962
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2965
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 39.47841760435743),
+      value("f64", 39.47841760435743),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2968
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -39.47841760435743),
+      value("f64", -39.47841760435743),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2971
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2974
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2977
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2980
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2983
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2986
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2989
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2992
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2995
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:2998
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013980551375161837),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3001
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.141592653589793),
+      value("f64", -3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3004
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.141592653589793),
+      value("f64", 3.141592653589793),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3007
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3010
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3013
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -39.47841760435743),
+      value("f64", -39.47841760435743),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3016
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 39.47841760435743),
+      value("f64", 39.47841760435743),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3019
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3022
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3025
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3028
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3031
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3034
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3037
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3040
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3043
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.9999999999999996),
+      value("f64", 3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3046
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.9999999999999996),
+      value("f64", -3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3049
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3052
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3055
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3058
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3061
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3064
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3067
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3070
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3073
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000008881784197001251),
+      value("f64", 0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3076
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000008881784197001251),
+      value("f64", 0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3079
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3082
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3085
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3088
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3091
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -3.9999999999999996),
+      value("f64", -3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3094
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 3.9999999999999996),
+      value("f64", 3.9999999999999996),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3097
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3100
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 89884656743115790000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3103
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3106
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3109
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3112
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3115
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3118
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3121
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000008881784197001251),
+      value("f64", -0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3124
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000008881784197001251),
+      value("f64", -0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3127
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3130
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3133
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3136
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3139
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3142
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3145
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3148
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3151
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3154
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3157
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3160
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3163
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000008881784197001251),
+      value("f64", 0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3166
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000008881784197001251),
+      value("f64", -0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3169
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3172
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3175
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3178
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3181
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3184
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3187
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3190
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3193
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3196
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3199
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3202
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3205
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3208
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3211
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000008881784197001251),
+      value("f64", 0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3214
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000008881784197001251),
+      value("f64", -0.0000000000000008881784197001251),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3217
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3220
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3223
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3226
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3229
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3232
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3235
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3238
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3241
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3244
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3247
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3250
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3253
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3256
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3259
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3262
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3265
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3268
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3271
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3274
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3277
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3280
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3283
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3286
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3289
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3292
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3295
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3298
+assert_return(
+  () => invoke($0, `f64x2.mul`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3301
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3304
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3307
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3310
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3313
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3316
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3319
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3322
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3325
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3328
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3331
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3334
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3337
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3340
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3343
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3346
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3349
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3352
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3355
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3358
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3361
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3364
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3367
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3370
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3373
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3376
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3379
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3382
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3385
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3388
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3391
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3394
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3397
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3400
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3403
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3406
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3409
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3412
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3415
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3418
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3421
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3424
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3427
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3430
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3433
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3436
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3439
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3442
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3445
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3448
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3451
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3454
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3457
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3460
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3463
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3466
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3469
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3472
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3475
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3478
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3481
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3484
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3487
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3490
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3493
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3496
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3499
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3502
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3505
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3508
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3511
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3514
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3517
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3520
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3523
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3526
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3529
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3532
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3535
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3538
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3541
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3544
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3547
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3550
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3553
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3556
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3559
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3562
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3565
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3568
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3571
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3574
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3577
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3580
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3583
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3586
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3589
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3592
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3595
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3598
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3601
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3604
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3607
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3610
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3613
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3616
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3619
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3622
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3625
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3628
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3631
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3634
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3637
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3640
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3643
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3646
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3649
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3652
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3655
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3658
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3661
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3664
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3667
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3670
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3673
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3676
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3679
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3682
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3685
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3688
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3691
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3694
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3697
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3700
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3703
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3706
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3709
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3712
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3715
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3718
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3721
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3724
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3727
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3730
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3733
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3736
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3739
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3742
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3745
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3748
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3751
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3754
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3757
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 15241578750190520),
+      value("f64", 15241578750190520),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3760
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3763
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3766
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000001524157875019052),
+      value("f64", 0.0000000000000000000001524157875019052),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3769
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 15241578750190520),
+      value("f64", 15241578750190520),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3772
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3775
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+      value("f64", 1524157875019052000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3778
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000001524157875019052),
+      value("f64", 0.0000000000000000000001524157875019052),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3781
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 15241578753238834),
+      value("f64", 15241578753238834),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3784
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1524157875323883800000000000000000000000000000000000000),
+      value("f64", 1524157875323883800000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3787
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1524157875323883800000000000000000000000000000000000000),
+      value("f64", 1524157875323883800000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3790
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000001524157875323884),
+      value("f64", 0.0000000000000000000001524157875323884),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3793
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1891969803538134400000000000000000000000000000000),
+      value("f64", 1891969803538134400000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3796
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3799
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3802
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6882946048929205000000000000000000000),
+      value("f64", 6882946048929205000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3805
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1891969803538134400000000000000000000000000000000),
+      value("f64", 1891969803538134400000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3808
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3811
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3814
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6882946048929205000000000000000000000),
+      value("f64", 6882946048929205000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3817
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1891969803538134400000000000000000000000000000000),
+      value("f64", 1891969803538134400000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3820
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3823
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+      value("f64", 520060699597813300000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3826
+assert_return(
+  () => invoke($0, `f64x2.mul`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6882946048929205000000000000000000000),
+      value("f64", 6882946048929205000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3829
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3832
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3835
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3838
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3841
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3844
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3847
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3850
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3853
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3856
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3859
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3862
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3865
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3868
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3871
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3874
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3877
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3880
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3883
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3886
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3889
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3892
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3895
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3898
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3901
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3904
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3907
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3910
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3913
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3916
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3919
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3922
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3925
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3928
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3931
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3934
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3937
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3940
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3943
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3946
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3949
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3952
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3955
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3958
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3961
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 4503599627370496), value("f64", 4503599627370496)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3964
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 4503599627370496), value("f64", 4503599627370496)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3967
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3970
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3973
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3976
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3979
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3982
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3985
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3988
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004450147717014403),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3991
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3994
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:3997
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4000
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003541315033259774),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4003
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4006
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4009
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -4503599627370496),
+      value("f64", -4503599627370496),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4012
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -4503599627370496),
+      value("f64", -4503599627370496),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4015
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4018
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4021
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4024
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4027
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4030
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4033
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4036
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4039
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4042
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4045
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.07957747154594767),
+      value("f64", 0.07957747154594767),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4048
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.07957747154594767),
+      value("f64", -0.07957747154594767),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4051
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4054
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4057
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4060
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4063
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4066
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4069
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4072
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4075
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4078
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 22471164185778950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4081
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4084
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4087
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4090
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4093
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.07957747154594767),
+      value("f64", -0.07957747154594767),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4096
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.07957747154594767),
+      value("f64", 0.07957747154594767),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4099
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4102
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002781342323134),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4105
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4108
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4111
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4114
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4117
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4120
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4123
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4126
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4129
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4132
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -2), value("f64", -2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4135
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4138
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4141
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.15915494309189535),
+      value("f64", 0.15915494309189535),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4144
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.15915494309189535),
+      value("f64", -0.15915494309189535),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4147
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4150
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4153
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4156
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4159
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4162
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4165
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4168
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4171
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4174
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4177
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -2), value("f64", -2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4180
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4183
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4186
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4189
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.15915494309189535),
+      value("f64", -0.15915494309189535),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4192
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.15915494309189535),
+      value("f64", 0.15915494309189535),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4195
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4198
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4201
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4204
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4207
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4210
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4213
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4216
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4219
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4222
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4225
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12.566370614359172),
+      value("f64", 12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4228
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -12.566370614359172),
+      value("f64", -12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4231
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4234
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4237
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4240
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4243
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4246
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+      value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4249
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4252
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4255
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4258
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4261
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4264
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4267
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4270
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4273
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -12.566370614359172),
+      value("f64", -12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4276
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 12.566370614359172),
+      value("f64", 12.566370614359172),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4279
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4282
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4285
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4288
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4291
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+      value("f64", -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4294
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000349513784379046),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4297
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4300
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4303
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4306
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4309
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4312
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4315
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4318
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4321
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4324
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4327
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4330
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4333
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4336
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4339
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4342
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4345
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4348
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4351
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4354
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4357
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4360
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4363
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4366
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4369
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4372
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4375
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4378
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4381
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4384
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 28611174857570280000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4387
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4390
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4393
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4396
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4399
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4402
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4405
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4408
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4411
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000002220446049250313),
+      value("f64", 0.0000000000000002220446049250313),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4414
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000002220446049250313),
+      value("f64", -0.0000000000000002220446049250313),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4417
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4420
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4423
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4426
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4429
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4432
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4435
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4438
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4441
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4444
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4447
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4450
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4453
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4456
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4459
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000002220446049250313),
+      value("f64", 0.0000000000000002220446049250313),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4462
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000000002220446049250313),
+      value("f64", -0.0000000000000002220446049250313),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4465
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4468
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+      value("f64", -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4471
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4474
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4477
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4480
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4483
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4486
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4489
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4492
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4495
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4498
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4501
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4504
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4507
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4510
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4513
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4516
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4519
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4522
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4525
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4528
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4531
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4534
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4537
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4540
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4543
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4546
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4549
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4552
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4555
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4558
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4561
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4564
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4567
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4570
+assert_return(
+  () => invoke($0, `f64x2.div`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4573
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4576
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4579
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4582
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4585
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4588
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4591
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4594
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4597
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4600
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4603
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4606
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4609
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4612
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4615
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4618
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4621
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4624
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4627
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4630
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4633
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4636
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4639
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4642
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4645
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4648
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4651
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4654
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4657
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4660
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4663
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4666
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4669
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4672
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4675
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4678
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4681
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4684
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4687
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4690
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4693
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4696
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4699
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4702
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4705
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4708
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4711
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4714
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4717
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4720
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4723
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4726
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4729
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4732
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4735
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4738
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4741
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4744
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4747
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4750
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4753
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4756
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4759
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4762
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4765
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4768
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4771
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4774
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4777
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4780
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4783
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4786
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4789
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4792
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4795
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4798
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4801
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4804
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4807
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4810
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4813
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4816
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4819
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4822
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4825
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4828
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4831
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4834
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4837
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4840
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4843
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4846
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4849
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4852
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4855
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4858
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4861
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4864
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4867
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4870
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4873
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4876
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4879
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4882
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4885
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4888
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4891
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4894
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4897
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4900
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4903
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4906
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4909
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4912
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4915
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4918
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4921
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4924
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4927
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4930
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4933
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4936
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4939
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4942
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4945
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4948
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4951
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4954
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4957
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4960
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4963
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4966
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4969
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4972
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4975
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4978
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4981
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4984
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4987
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4990
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4993
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4996
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:4999
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5002
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5005
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5008
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5011
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5014
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5017
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5020
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5023
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5026
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5029
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5032
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5035
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5038
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5041
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5044
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5047
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5050
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5053
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5056
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5059
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5062
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5065
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5068
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5071
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5074
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5077
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5080
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5083
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5086
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5089
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5092
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5095
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5098
+assert_return(
+  () => invoke($0, `f64x2.div`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5101
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5103
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5105
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014916681462400413),
+      value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014916681462400413),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5107
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5109
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([0.5, 0.5])]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.7071067811865476),
+      value("f64", 0.7071067811865476),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5111
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5113
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5115
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5117
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2.5066282746310002),
+      value("f64", 2.5066282746310002),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5119
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5121
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5123
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5125
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022227587494850775),
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022227587494850775),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5127
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022227587494850775),
+      value("f64", 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022227587494850775),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5129
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5131
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5133
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5135
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5137
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5139
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5141
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([123456789, 123456789])]),
+  [
+    new F64x2Pattern(
+      value("f64", 11111.111060555555),
+      value("f64", 11111.111060555555),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5143
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 35136418286444.62),
+      value("f64", 35136418286444.62),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5145
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 35136418286444.62),
+      value("f64", 35136418286444.62),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5147
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000035136418286444623),
+      value("f64", 0.0000035136418286444623),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5149
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([123456789, 123456789])]),
+  [
+    new F64x2Pattern(
+      value("f64", 11111.111060555555),
+      value("f64", 11111.111060555555),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5151
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 35136418286444.62),
+      value("f64", 35136418286444.62),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5153
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 35136418286444.62),
+      value("f64", 35136418286444.62),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5155
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000035136418286444623),
+      value("f64", 0.0000035136418286444623),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5157
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([123456789.01234567, 123456789.01234567])]),
+  [
+    new F64x2Pattern(
+      value("f64", 11111.11106111111),
+      value("f64", 11111.11106111111),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5159
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 35136418288201.445),
+      value("f64", 35136418288201.445),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5161
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 35136418288201.445),
+      value("f64", 35136418288201.445),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5163
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000003513641828820144),
+      value("f64", 0.000003513641828820144),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5165
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1172812402961.0667),
+      value("f64", 1172812402961.0667),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5167
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 849206889670103), value("f64", 849206889670103)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5169
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 849206889670103), value("f64", 849206889670103)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5171
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 1619733599.9872265),
+      value("f64", 1619733599.9872265),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5173
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1172812402961.0667),
+      value("f64", 1172812402961.0667),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5175
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 849206889670103), value("f64", 849206889670103)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5177
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 849206889670103), value("f64", 849206889670103)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5179
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 1619733599.9872265),
+      value("f64", 1619733599.9872265),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5181
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1172812402961.0667),
+      value("f64", 1172812402961.0667),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5183
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 849206889670103), value("f64", 849206889670103)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5185
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 849206889670103), value("f64", 849206889670103)),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5187
+assert_return(
+  () => invoke($0, `f64x2.sqrt`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 1619733599.9872265),
+      value("f64", 1619733599.9872265),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5189
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5191
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5193
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5195
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5197
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5199
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5201
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5203
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5205
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5207
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5209
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5211
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5213
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5215
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5217
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5219
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5221
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5223
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5225
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5227
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5229
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -123456789), value("f64", -123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5231
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890000000000000000000),
+      value("f64", -1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5233
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890000000000000000000),
+      value("f64", -1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5235
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([0.0000000000123456789, 0.0000000000123456789])]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000123456789),
+      value("f64", -0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5237
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -123456789), value("f64", -123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5239
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890000000000000000000),
+      value("f64", -1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5241
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890000000000000000000),
+      value("f64", -1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5243
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([0.0000000000123456789, 0.0000000000123456789])]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.0000000000123456789),
+      value("f64", -0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5245
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([123456789.01234567, 123456789.01234567])]),
+  [
+    new F64x2Pattern(
+      value("f64", -123456789.01234567),
+      value("f64", -123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5247
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456900000000000),
+      value("f64", -1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5249
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1234567890123456900000000000),
+      value("f64", -1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5251
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000012345678901234568),
+      value("f64", -0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5253
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1375488932539311400000000),
+      value("f64", -1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5255
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -721152341463170500000000000000),
+      value("f64", -721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5257
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -721152341463170500000000000000),
+      value("f64", -721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5259
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", -2623536934927580700),
+      value("f64", -2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5261
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1375488932539311400000000),
+      value("f64", -1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5263
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -721152341463170500000000000000),
+      value("f64", -721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5265
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -721152341463170500000000000000),
+      value("f64", -721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5267
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", -2623536934927580700),
+      value("f64", -2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5269
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -1375488932539311400000000),
+      value("f64", -1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5271
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -721152341463170500000000000000),
+      value("f64", -721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5273
+assert_return(
+  () => invoke($0, `f64x2.neg`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -721152341463170500000000000000),
+      value("f64", -721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5275
+assert_return(
+  () => invoke($0, `f64x2.neg`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", -2623536934927580700),
+      value("f64", -2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5279
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5294
+assert_return(
+  () => invoke($1, `f64x2_add_arith`, []),
+  [new F64x2Pattern(`arithmetic_nan`, value("f64", 2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5295
+assert_return(
+  () => invoke($1, `f64x2_div_mixed`, []),
+  [new F64x2Pattern(`canonical_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5296
+assert_return(
+  () => invoke($1, `f64x2_mul_mixed`, []),
+  [new F64x2Pattern(`arithmetic_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5297
+assert_return(
+  () => invoke($1, `f64x2_neg_canon`, []),
+  [new F64x2Pattern(`canonical_nan`, value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5298
+assert_return(
+  () => invoke($1, `f64x2_sqrt_canon`, []),
+  [new F64x2Pattern(value("f64", 2), `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5299
+assert_return(
+  () => invoke($1, `f64x2_sub_arith`, []),
+  [new F64x2Pattern(`canonical_nan`, value("f64", -2))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5302
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.neg (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5303
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.sqrt (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5304
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.add (i64.const 0) (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5305
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.sub (i64.const 0) (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5306
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5307
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5311
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.neg-arg-empty (result v128)
+      (f64x2.neg)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5319
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.sqrt-arg-empty (result v128)
+      (f64x2.sqrt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5327
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.add-1st-arg-empty (result v128)
+      (f64x2.add (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5335
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.add-arg-empty (result v128)
+      (f64x2.add)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5343
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.sub-1st-arg-empty (result v128)
+      (f64x2.sub (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5351
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.sub-arg-empty (result v128)
+      (f64x2.sub)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5359
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.mul-1st-arg-empty (result v128)
+      (f64x2.mul (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5367
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.mul-arg-empty (result v128)
+      (f64x2.mul)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5375
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.div-1st-arg-empty (result v128)
+      (f64x2.div (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5383
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.div-arg-empty (result v128)
+      (f64x2.div)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5393
+let $2 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5428
+assert_return(
+  () => invoke($2, `add-sub`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.25, 0.25]),
+    f64x2([0.125, 0.125]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5432
+assert_return(
+  () => invoke($2, `div-add`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.125, 0.125]),
+    f64x2([0.25, 0.25]),
+  ]),
+  [new F64x2Pattern(value("f64", 5), value("f64", 5))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5436
+assert_return(
+  () => invoke($2, `div-mul`, [
+    f64x2([1.125, 1.125]),
+    f64x2([4, 4]),
+    f64x2([0.25, 0.25]),
+  ]),
+  [new F64x2Pattern(value("f64", 18), value("f64", 18))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5440
+assert_return(
+  () => invoke($2, `div-sub`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.125, 0.125]),
+    f64x2([0.25, 0.25]),
+  ]),
+  [new F64x2Pattern(value("f64", 4), value("f64", 4))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5444
+assert_return(
+  () => invoke($2, `mul-add`, [
+    f64x2([1.25, 1.25]),
+    f64x2([0.25, 0.25]),
+    f64x2([0.25, 0.25]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.375), value("f64", 0.375))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5448
+assert_return(
+  () => invoke($2, `mul-div`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.125, 0.125]),
+    f64x2([0.25, 0.25]),
+  ]),
+  [new F64x2Pattern(value("f64", 2.25), value("f64", 2.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5452
+assert_return(
+  () => invoke($2, `mul-sub`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.125, 0.125]),
+    f64x2([0.25, 0.25]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.25), value("f64", 0.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5456
+assert_return(
+  () => invoke($2, `sub-add`, [
+    f64x2([1.125, 1.125]),
+    f64x2([0.25, 0.25]),
+    f64x2([0.125, 0.125]),
+  ]),
+  [new F64x2Pattern(value("f64", 1.25), value("f64", 1.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5460
+assert_return(
+  () => invoke($2, `add-neg`, [f64x2([1.125, 1.125]), f64x2([0.125, 0.125])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5463
+assert_return(
+  () => invoke($2, `add-sqrt`, [f64x2([2.25, 2.25]), f64x2([0.25, 0.25])]),
+  [new F64x2Pattern(value("f64", 1.75), value("f64", 1.75))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5466
+assert_return(
+  () => invoke($2, `div-neg`, [f64x2([1.5, 1.5]), f64x2([0.25, 0.25])]),
+  [new F64x2Pattern(value("f64", -6), value("f64", -6))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5469
+assert_return(
+  () => invoke($2, `div-sqrt`, [f64x2([2.25, 2.25]), f64x2([0.25, 0.25])]),
+  [new F64x2Pattern(value("f64", 6), value("f64", 6))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5472
+assert_return(
+  () => invoke($2, `mul-neg`, [f64x2([1.5, 1.5]), f64x2([0.25, 0.25])]),
+  [new F64x2Pattern(value("f64", -0.375), value("f64", -0.375))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5475
+assert_return(
+  () => invoke($2, `mul-sqrt`, [f64x2([2.25, 2.25]), f64x2([0.25, 0.25])]),
+  [new F64x2Pattern(value("f64", 0.375), value("f64", 0.375))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5478
+assert_return(
+  () => invoke($2, `sub-neg`, [f64x2([1.125, 1.125]), f64x2([0.125, 0.125])]),
+  [new F64x2Pattern(value("f64", -1.25), value("f64", -1.25))],
+);
+
+// ./test/core/simd/simd_f64x2_arith.wast:5481
+assert_return(
+  () => invoke($2, `sub-sqrt`, [f64x2([2.25, 2.25]), f64x2([0.25, 0.25])]),
+  [new F64x2Pattern(value("f64", 1.25), value("f64", 1.25))],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js
new file mode 100644
index 0000000000..81d377b40d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_cmp.wast.js
@@ -0,0 +1,43747 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f64x2_cmp.wast
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:13
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:16
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:19
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:22
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:25
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:28
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:31
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:34
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:37
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:40
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:43
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:46
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:49
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:52
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:55
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:58
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:61
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:64
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:67
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:70
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:73
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:76
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:79
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:82
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:85
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:88
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:91
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:94
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:97
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:100
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:103
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:106
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:109
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:112
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:115
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:118
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:121
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:124
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:127
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:130
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:133
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:136
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:139
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:142
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:145
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:148
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:151
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:154
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:157
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:160
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:163
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:166
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:169
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:172
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:175
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:178
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:181
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:184
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:187
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:190
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:193
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:196
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:199
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:202
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:205
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:208
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:211
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:214
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:217
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:220
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:223
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:226
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:229
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:232
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:235
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:238
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:241
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:244
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:247
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:250
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:253
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:256
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:259
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:262
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:265
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:268
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:271
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:274
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:277
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:280
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:283
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:286
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:289
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:292
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:295
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:298
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:301
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:304
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:307
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:310
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:313
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:316
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:319
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:322
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:325
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:328
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:331
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:334
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:337
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:340
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:343
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:346
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:349
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:352
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:355
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-0, -0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:358
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:361
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:364
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:367
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:370
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:373
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:376
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:379
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:382
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:385
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:388
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:391
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:394
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:397
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:400
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:403
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:406
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:409
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:412
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:415
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:418
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:421
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:424
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:427
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:430
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:433
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:436
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:439
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:442
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:445
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:448
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:451
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:454
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:457
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:460
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:463
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:466
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:469
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:472
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:475
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:478
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:481
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:484
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:487
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:490
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:493
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:496
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:499
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:502
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:505
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:508
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:511
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:514
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:517
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:520
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:523
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:526
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:529
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:532
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:535
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:538
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:541
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:544
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:547
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:550
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:553
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:556
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:559
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:562
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:565
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:568
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:571
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:574
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:577
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:580
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:583
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:586
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:589
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:592
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:595
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:598
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:601
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:604
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:607
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:610
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:613
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:616
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:619
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:622
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:625
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:628
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:631
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:634
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:637
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:640
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:643
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:646
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:649
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:652
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:655
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:658
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:661
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:664
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:667
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:670
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:673
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:676
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:679
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:682
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:685
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:688
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:691
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:694
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:697
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:700
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:703
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:706
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:709
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:712
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:715
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:718
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:721
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:724
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:727
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:730
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:733
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:736
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:739
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:742
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:745
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:748
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:751
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:754
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:757
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:760
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:763
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:766
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:769
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:772
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:775
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:778
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:781
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:784
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:787
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:790
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:793
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:796
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:799
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:802
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:805
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:808
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:811
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:814
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:817
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:820
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:823
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:826
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:829
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:832
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:835
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:838
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:841
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:844
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:847
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:850
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:853
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:856
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:859
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:862
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:865
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:868
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:871
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:874
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:877
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:880
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:883
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:886
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:889
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:892
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:895
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:898
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:901
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:904
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:907
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:910
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:913
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:916
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:919
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:922
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:925
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:928
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:931
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:934
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:937
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:940
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:943
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:946
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:949
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:952
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:955
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:958
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:961
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:964
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:967
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:970
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:973
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:976
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:979
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:982
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:985
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:988
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:991
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:994
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:997
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1000
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1003
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1006
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1009
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1012
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1015
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1018
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1021
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1024
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1027
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1030
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1033
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1036
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1039
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1042
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1045
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1048
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1051
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1054
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1057
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1060
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1063
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1066
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1069
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1072
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1075
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1078
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1081
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1084
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1087
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1090
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1093
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1096
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1099
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1102
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1105
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1108
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1111
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1114
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1117
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1120
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1123
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1126
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1129
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1132
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1135
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1138
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1141
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1144
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1147
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1150
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1153
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1156
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1159
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1162
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1165
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1168
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1171
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1174
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1177
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1180
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1183
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1186
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1189
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1192
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1195
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1198
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1201
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1204
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1207
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1210
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1213
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1216
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1219
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1222
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1225
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1228
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1231
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1234
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1237
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1240
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1243
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1246
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1249
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1252
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1255
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1258
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1261
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1264
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1267
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1270
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1273
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1276
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1279
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1282
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1285
+assert_return(
+  () => invoke($0, `f64x2.eq`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1288
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1291
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1294
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1297
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1300
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1303
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1306
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1309
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1312
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1315
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1318
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1321
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1324
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1327
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1330
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1333
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1336
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1339
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1342
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1345
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1348
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1351
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1354
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1357
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1360
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1363
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1366
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1369
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1372
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1375
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1378
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1381
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1384
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1387
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1390
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1393
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1396
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1399
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1402
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1405
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1408
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1411
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1414
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1417
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1420
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1423
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1426
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1429
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1432
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1435
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1438
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1441
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1444
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1447
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1450
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1453
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1456
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1459
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1462
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1465
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1468
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1471
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1474
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1477
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1480
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1483
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1486
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1489
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1492
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1495
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1498
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1501
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1504
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1507
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1510
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1513
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1516
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1519
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1522
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1525
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1528
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1531
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1534
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1537
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1540
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1543
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1546
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1549
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1552
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1555
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1558
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1561
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1564
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1567
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1570
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1573
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1576
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1579
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1582
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1585
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1588
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1591
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1594
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1597
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1600
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1603
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1606
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1609
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1612
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1615
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1618
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1621
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1624
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1627
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1630
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1633
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1636
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1639
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1642
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1645
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1648
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1651
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1654
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1657
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1660
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1663
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1666
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1669
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1672
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1675
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1678
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1681
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1684
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1687
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1690
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1693
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1696
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1699
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1702
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1705
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1708
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1711
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1714
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1717
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1720
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1723
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1726
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1729
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1732
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1735
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1738
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1741
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1744
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1747
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1750
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1753
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1756
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1759
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1762
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1765
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1768
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1771
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1774
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1777
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1780
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1783
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1786
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1789
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1792
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1795
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1798
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1801
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1804
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1807
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1810
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1813
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1816
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1819
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1822
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1825
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1828
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1831
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1834
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1837
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1840
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1843
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1846
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1849
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1852
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1855
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1858
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1861
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1864
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1867
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1870
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1873
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1876
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1879
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1882
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1885
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1888
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1891
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1894
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1897
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1900
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1903
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1906
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1909
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1912
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1915
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1918
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1921
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1924
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1927
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1930
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1933
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1936
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1939
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1942
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1945
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1948
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1951
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1954
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1957
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1960
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1963
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1966
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1969
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1972
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1975
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1978
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1981
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1984
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1987
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1990
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1993
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1996
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:1999
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2002
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2005
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2008
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2011
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2014
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2017
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2020
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2023
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2026
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2029
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2032
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2035
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2038
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2041
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2044
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2047
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2050
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2053
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2056
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2059
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2062
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2065
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2068
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2071
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2074
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2077
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2080
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2083
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2086
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2089
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2092
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2095
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2098
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2101
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2104
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2107
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2110
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2113
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2116
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2119
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2122
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2125
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2128
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2131
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2134
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2137
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2140
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2143
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2146
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2149
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2152
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2155
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2158
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2161
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2164
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2167
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2170
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2173
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2176
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2179
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2182
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2185
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2188
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2191
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2194
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2197
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2200
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2203
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2206
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2209
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2212
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2215
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2218
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2221
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2224
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2227
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2230
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2233
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2236
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2239
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2242
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2245
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2248
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2251
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2254
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2257
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2260
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2263
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2266
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2269
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2272
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2275
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2278
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2281
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2284
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2287
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2290
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2293
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2296
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2299
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2302
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2305
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2308
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2311
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2314
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2317
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2320
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2323
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2326
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2329
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2332
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2335
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2338
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2341
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2344
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2347
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2350
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2353
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2356
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2359
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2362
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2365
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2368
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2371
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2374
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2377
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2380
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2383
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2386
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2389
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2392
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2395
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2398
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2401
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2404
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2407
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2410
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2413
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2416
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2419
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2422
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2425
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2428
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2431
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2434
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2437
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2440
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2443
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2446
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2449
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2452
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2455
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2458
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2461
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2464
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2467
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2470
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2473
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2476
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2479
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2482
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2485
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2488
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2491
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2494
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2497
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2500
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2503
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2506
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2509
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2512
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2515
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2518
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2521
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2524
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2527
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2530
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2533
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2536
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2539
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2542
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2545
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2548
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2551
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2554
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2557
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2560
+assert_return(
+  () => invoke($0, `f64x2.ne`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2563
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2566
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2569
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2572
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2575
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2578
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2581
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2584
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2587
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2590
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2593
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2596
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2599
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2602
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2605
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2608
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2611
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2614
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2617
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2620
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2623
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2626
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2629
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2632
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2635
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2638
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2641
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2644
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2647
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2650
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2653
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2656
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2659
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2662
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2665
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2668
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2671
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2674
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2677
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2680
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2683
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2686
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2689
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2692
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2695
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2698
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2701
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2704
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2707
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2710
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2713
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2716
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2719
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2722
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2725
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2728
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2731
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2734
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2737
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2740
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2743
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2746
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2749
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2752
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2755
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2758
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2761
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2764
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2767
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2770
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2773
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2776
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2779
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2782
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2785
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2788
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2791
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2794
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2797
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2800
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2803
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2806
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2809
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2812
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2815
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2818
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2821
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2824
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2827
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2830
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2833
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2836
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2839
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2842
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2845
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2848
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2851
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2854
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2857
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2860
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2863
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2866
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2869
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2872
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2875
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2878
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2881
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2884
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2887
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2890
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2893
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2896
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2899
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2902
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2905
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([-0, -0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2908
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2911
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2914
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2917
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2920
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2923
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2926
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2929
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2932
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2935
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2938
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2941
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2944
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2947
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2950
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2953
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2956
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2959
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2962
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2965
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2968
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2971
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2974
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2977
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2980
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2983
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2986
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2989
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2992
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2995
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:2998
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3001
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3004
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3007
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3010
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3013
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3016
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3019
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3022
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3025
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3028
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3031
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3034
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3037
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3040
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3043
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3046
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3049
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3052
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3055
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3058
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3061
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3064
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3067
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3070
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3073
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3076
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3079
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3082
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3085
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3088
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3091
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3094
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3097
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3100
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3103
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3106
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3109
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3112
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3115
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3118
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3121
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3124
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3127
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3130
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3133
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3136
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3139
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3142
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3145
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3148
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3151
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3154
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3157
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3160
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3163
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3166
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3169
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3172
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3175
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3178
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3181
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3184
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3187
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3190
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3193
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3196
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3199
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3202
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3205
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3208
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3211
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3214
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3217
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3220
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3223
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3226
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3229
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3232
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3235
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3238
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3241
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3244
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3247
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3250
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3253
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3256
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3259
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3262
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3265
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3268
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3271
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3274
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3277
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3280
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3283
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3286
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3289
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3292
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3295
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3298
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3301
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3304
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3307
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3310
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3313
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3316
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3319
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3322
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3325
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3328
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3331
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3334
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3337
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3340
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3343
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3346
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3349
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3352
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3355
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3358
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3361
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3364
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3367
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3370
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3373
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3376
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3379
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3382
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3385
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3388
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3391
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3394
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3397
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3400
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3403
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3406
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3409
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3412
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3415
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3418
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3421
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3424
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3427
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3430
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3433
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3436
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3439
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3442
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3445
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3448
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3451
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3454
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3457
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3460
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3463
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3466
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3469
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3472
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3475
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3478
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3481
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3484
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3487
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3490
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3493
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3496
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3499
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3502
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3505
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3508
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3511
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3514
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3517
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3520
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3523
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3526
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3529
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3532
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3535
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3538
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3541
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3544
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3547
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3550
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3553
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3556
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3559
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3562
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3565
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3568
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3571
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3574
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3577
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3580
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3583
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3586
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3589
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3592
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3595
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3598
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3601
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3604
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3607
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3610
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3613
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3616
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3619
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3622
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3625
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3628
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3631
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3634
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3637
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3640
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3643
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3646
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3649
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3652
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3655
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3658
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3661
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3664
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3667
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3670
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3673
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3676
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3679
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3682
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3685
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3688
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3691
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3694
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3697
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3700
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3703
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3706
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3709
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3712
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3715
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3718
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3721
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3724
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3727
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3730
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3733
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3736
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3739
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3742
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3745
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3748
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3751
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3754
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3757
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3760
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3763
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3766
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3769
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3772
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3775
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3778
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3781
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3784
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3787
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3790
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3793
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3796
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3799
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3802
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3805
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3808
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3811
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3814
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3817
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3820
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3823
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3826
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3829
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3832
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3835
+assert_return(
+  () => invoke($0, `f64x2.lt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3838
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3841
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3844
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3847
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3850
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3853
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3856
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3859
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3862
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3865
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3868
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3871
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3874
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3877
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3880
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3883
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3886
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3889
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3892
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3895
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3898
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3901
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3904
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3907
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3910
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3913
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3916
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3919
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3922
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3925
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3928
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3931
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3934
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3937
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3940
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3943
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3946
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3949
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3952
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3955
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3958
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3961
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3964
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3967
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3970
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3973
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3976
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3979
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3982
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3985
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3988
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3991
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3994
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:3997
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4000
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4003
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4006
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4009
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4012
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4015
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4018
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4021
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4024
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4027
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4030
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4033
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4036
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4039
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4042
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4045
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4048
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4051
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4054
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4057
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4060
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4063
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4066
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4069
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4072
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4075
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4078
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4081
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4084
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4087
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4090
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4093
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4096
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4099
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4102
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4105
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4108
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4111
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4114
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4117
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4120
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4123
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4126
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4129
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4132
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4135
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4138
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4141
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4144
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4147
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4150
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4153
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4156
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4159
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4162
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4165
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4168
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4171
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4174
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4177
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4180
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([-0, -0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4183
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4186
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4189
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4192
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4195
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4198
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4201
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4204
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4207
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4210
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4213
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4216
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4219
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4222
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4225
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4228
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4231
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4234
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4237
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4240
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4243
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4246
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4249
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4252
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4255
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4258
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4261
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4264
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4267
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4270
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4273
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4276
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4279
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4282
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4285
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4288
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4291
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4294
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4297
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4300
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4303
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4306
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4309
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4312
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4315
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4318
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4321
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4324
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4327
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4330
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4333
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4336
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4339
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4342
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4345
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4348
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4351
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4354
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4357
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4360
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4363
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4366
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4369
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4372
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4375
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4378
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4381
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4384
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4387
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4390
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4393
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4396
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4399
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4402
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4405
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4408
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4411
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4414
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4417
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4420
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4423
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4426
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4429
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4432
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4435
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4438
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4441
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4444
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4447
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4450
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4453
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4456
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4459
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4462
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4465
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4468
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4471
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4474
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4477
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4480
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4483
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4486
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4489
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4492
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4495
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4498
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4501
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4504
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4507
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4510
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4513
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4516
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4519
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4522
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4525
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4528
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4531
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4534
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4537
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4540
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4543
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4546
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4549
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4552
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4555
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4558
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4561
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4564
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4567
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4570
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4573
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4576
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4579
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4582
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4585
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4588
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4591
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4594
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4597
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4600
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4603
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4606
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4609
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4612
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4615
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4618
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4621
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4624
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4627
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4630
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4633
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4636
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4639
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4642
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4645
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4648
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4651
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4654
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4657
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4660
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4663
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4666
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4669
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4672
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4675
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4678
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4681
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4684
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4687
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4690
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4693
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4696
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4699
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4702
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4705
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4708
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4711
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4714
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4717
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4720
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4723
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4726
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4729
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4732
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4735
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4738
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4741
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4744
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4747
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4750
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4753
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4756
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4759
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4762
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4765
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4768
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4771
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4774
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4777
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4780
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4783
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4786
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4789
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4792
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4795
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4798
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4801
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4804
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4807
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4810
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4813
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4816
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4819
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4822
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4825
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4828
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4831
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4834
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4837
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4840
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4843
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4846
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4849
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4852
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4855
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4858
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4861
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4864
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4867
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4870
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4873
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4876
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4879
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4882
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4885
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4888
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4891
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4894
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4897
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4900
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4903
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4906
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4909
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4912
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4915
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4918
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4921
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4924
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4927
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4930
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4933
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4936
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4939
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4942
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4945
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4948
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4951
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4954
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4957
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4960
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4963
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4966
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4969
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4972
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4975
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4978
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4981
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4984
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4987
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4990
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4993
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4996
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:4999
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5002
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5005
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5008
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5011
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5014
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5017
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5020
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5023
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5026
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5029
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5032
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5035
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5038
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5041
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5044
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5047
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5050
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5053
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5056
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5059
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5062
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5065
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5068
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5071
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5074
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5077
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5080
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5083
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5086
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5089
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5092
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5095
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5098
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5101
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5104
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5107
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5110
+assert_return(
+  () => invoke($0, `f64x2.le`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5113
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5116
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5119
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5122
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5125
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5128
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5131
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5134
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5137
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5140
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5143
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5146
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5149
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5152
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5155
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5158
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5161
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5164
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5167
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5170
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5173
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5176
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5179
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5182
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5185
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5188
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5191
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5194
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5197
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5200
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5203
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5206
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5209
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5212
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5215
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5218
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5221
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5224
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5227
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5230
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5233
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5236
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5239
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5242
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5245
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5248
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5251
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5254
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5257
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5260
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5263
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5266
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5269
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5272
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5275
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5278
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5281
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5284
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5287
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5290
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5293
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5296
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5299
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5302
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5305
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5308
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5311
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5314
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5317
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5320
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5323
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5326
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5329
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5332
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5335
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5338
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5341
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5344
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5347
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5350
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5353
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5356
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5359
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5362
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5365
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5368
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5371
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5374
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5377
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5380
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5383
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5386
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5389
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5392
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5395
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5398
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5401
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5404
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5407
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5410
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5413
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5416
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5419
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5422
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5425
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5428
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5431
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5434
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5437
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5440
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5443
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5446
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5449
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5452
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5455
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5458
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5461
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5464
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5467
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5470
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5473
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5476
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5479
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5482
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5485
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5488
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5491
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5494
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5497
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5500
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5503
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5506
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5509
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5512
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5515
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5518
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5521
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5524
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5527
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5530
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5533
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5536
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5539
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5542
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5545
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5548
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5551
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5554
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5557
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5560
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5563
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5566
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5569
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5572
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5575
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5578
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5581
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5584
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5587
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5590
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5593
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5596
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5599
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5602
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5605
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5608
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5611
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5614
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5617
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5620
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5623
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5626
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5629
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5632
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5635
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5638
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5641
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5644
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5647
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5650
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5653
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5656
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5659
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5662
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5665
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5668
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5671
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5674
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5677
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5680
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5683
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5686
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5689
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5692
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5695
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5698
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5701
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5704
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5707
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5710
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5713
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5716
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5719
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5722
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5725
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5728
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5731
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5734
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5737
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5740
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5743
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5746
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5749
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5752
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5755
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5758
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5761
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5764
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5767
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5770
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5773
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5776
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5779
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5782
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5785
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5788
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5791
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5794
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5797
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5800
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5803
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5806
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5809
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5812
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5815
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5818
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5821
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5824
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5827
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5830
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5833
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5836
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5839
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5842
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5845
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5848
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5851
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5854
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5857
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5860
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5863
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5866
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5869
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5872
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5875
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5878
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5881
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5884
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5887
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5890
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5893
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5896
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5899
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5902
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5905
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5908
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5911
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5914
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5917
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5920
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5923
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5926
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5929
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5932
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5935
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5938
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5941
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5944
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5947
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5950
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5953
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5956
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5959
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5962
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5965
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5968
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5971
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5974
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5977
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5980
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5983
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5986
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5989
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5992
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5995
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:5998
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6001
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6004
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6007
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6010
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6013
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6016
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6019
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6022
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6025
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6028
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6031
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6034
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6037
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6040
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6043
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6046
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6049
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6052
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6055
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6058
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6061
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6064
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6067
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6070
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6073
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6076
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6079
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6082
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6085
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6088
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6091
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6094
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6097
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6100
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6103
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6106
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6109
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6112
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6115
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6118
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6121
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6124
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6127
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6130
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6133
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6136
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6139
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6142
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6145
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6148
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6151
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6154
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6157
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6160
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6163
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6166
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6169
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6172
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6175
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6178
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6181
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6184
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6187
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6190
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6193
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6196
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6199
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6202
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6205
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6208
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6211
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6214
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6217
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6220
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6223
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6226
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6229
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6232
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6235
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6238
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6241
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6244
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6247
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6250
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6253
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6256
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6259
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6262
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6265
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6268
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6271
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6274
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6277
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6280
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6283
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6286
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6289
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6292
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6295
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6298
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6301
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6304
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6307
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6310
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6313
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6316
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6319
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6322
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6325
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6328
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6331
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6334
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6337
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6340
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6343
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6346
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6349
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6352
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6355
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6358
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6361
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6364
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6367
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6370
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6373
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6376
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6379
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6382
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6385
+assert_return(
+  () => invoke($0, `f64x2.gt`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6388
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6391
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6394
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6397
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6400
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6403
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6406
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6409
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6412
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6415
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6418
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6421
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6424
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6427
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6430
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6433
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6436
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6439
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6442
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6445
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6448
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6451
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6454
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6457
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6460
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6463
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6466
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6469
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6472
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6475
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6478
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6481
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6484
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6487
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6490
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6493
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6496
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6499
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6502
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6505
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6508
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6511
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6514
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6517
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6520
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6523
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6526
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6529
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6532
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6535
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6538
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6541
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6544
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6547
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6550
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6553
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6556
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6559
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6562
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6565
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6568
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6571
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6574
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6577
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6580
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6583
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6586
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6589
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6592
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6595
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6598
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6601
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6604
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6607
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6610
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6613
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6616
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6619
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6622
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6625
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6628
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6631
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6634
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6637
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6640
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6643
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6646
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6649
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6652
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6655
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6658
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6661
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6664
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6667
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6670
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6673
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6676
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6679
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6682
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6685
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6688
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6691
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6694
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6697
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6700
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6703
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6706
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6709
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6712
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6715
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6718
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6721
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6724
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6727
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6730
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6733
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6736
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6739
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6742
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6745
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6748
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6751
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6754
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6757
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6760
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6763
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6766
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6769
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6772
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6775
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6778
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6781
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6784
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6787
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6790
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6793
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6796
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6799
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6802
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6805
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6808
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6811
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6814
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6817
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6820
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6823
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6826
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6829
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6832
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6835
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6838
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6841
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6844
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6847
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6850
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6853
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6856
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6859
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6862
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6865
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6868
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6871
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6874
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6877
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6880
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6883
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6886
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6889
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6892
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6895
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6898
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6901
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6904
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6907
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6910
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6913
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6916
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6919
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6922
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6925
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6928
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6931
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6934
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6937
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6940
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6943
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6946
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6949
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6952
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6955
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6958
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6961
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6964
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6967
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6970
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6973
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6976
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6979
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6982
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6985
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6988
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6991
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6994
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:6997
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7000
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7003
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7006
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7009
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7012
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7015
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7018
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7021
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7024
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7027
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7030
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7033
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7036
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7039
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7042
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7045
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7048
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7051
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7054
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7057
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7060
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7063
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7066
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7069
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7072
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7075
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7078
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7081
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7084
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7087
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7090
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7093
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7096
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7099
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7102
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7105
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7108
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7111
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7114
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7117
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7120
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7123
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7126
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7129
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7132
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7135
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7138
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7141
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7144
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7147
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7150
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7153
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7156
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7159
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7162
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7165
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7168
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7171
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7174
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7177
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7180
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7183
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7186
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7189
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7192
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7195
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7198
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7201
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7204
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7207
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7210
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7213
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7216
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7219
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7222
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7225
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7228
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7231
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7234
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7237
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7240
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7243
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([-0, -0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7246
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7249
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7252
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7255
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7258
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7261
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7264
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7267
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7270
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7273
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7276
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7279
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7282
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7285
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7288
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7291
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7294
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7297
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7300
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7303
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7306
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7309
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7312
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7315
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7318
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7321
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7324
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7327
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7330
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7333
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7336
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7339
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7342
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7345
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7348
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7351
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7354
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7357
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7360
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7363
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7366
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7369
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7372
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7375
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7378
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7381
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7384
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7387
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7390
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7393
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7396
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7399
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7402
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7405
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7408
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      123456789012345690000000000000000000000000000000000000000,
+      123456789012345690000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7411
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([0.000000000000000000012345678901234569, 0.000000000000000000012345678901234569]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7414
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7417
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([
+      12345678900000000000000000000000000000000000000,
+      12345678900000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7420
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    f64x2([1234567890123456800, 1234567890123456800]),
+    f64x2([1234567890123456800, 1234567890123456800]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7423
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7426
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7429
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7432
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7435
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7438
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7441
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7444
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7447
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7450
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7453
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7456
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7459
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7462
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7465
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7468
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7471
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7474
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7477
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7480
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7483
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7486
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7489
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7492
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7495
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7498
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7501
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7504
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7507
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7510
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7513
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7516
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7519
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7522
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7525
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7528
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7531
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7534
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7537
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7540
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7543
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7546
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7549
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7552
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7555
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7558
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7561
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7564
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7567
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7570
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7573
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7576
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7579
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7582
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7585
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7588
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7591
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7594
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7597
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7600
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7603
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7606
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7609
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7612
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7615
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7618
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7621
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7624
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7627
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7630
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7633
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7636
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7639
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7642
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7645
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7648
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7651
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7654
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7657
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7660
+assert_return(
+  () => invoke($0, `f64x2.ge`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7663
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7666
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7669
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7672
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([-1, -1]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7675
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7678
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7681
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7684
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([0, 0]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7687
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7690
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7693
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7696
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([1, 1]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7699
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([2, 2]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7702
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([2, 2]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7705
+assert_return(() => invoke($0, `f64x2.eq`, [f64x2([2, 2]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7708
+assert_return(
+  () => invoke($0, `f64x2.eq`, [f64x2([2, 2]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7711
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7714
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7717
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7720
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([-1, -1]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7723
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7726
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7729
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7732
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([0, 0]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7735
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7738
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7741
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7744
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([1, 1]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7747
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([2, 2]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7750
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([2, 2]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7753
+assert_return(
+  () => invoke($0, `f64x2.ne`, [f64x2([2, 2]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7756
+assert_return(() => invoke($0, `f64x2.ne`, [f64x2([2, 2]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7759
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7762
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7765
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7768
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([-1, -1]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7771
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7774
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7777
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7780
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([0, 0]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7783
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7786
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7789
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7792
+assert_return(
+  () => invoke($0, `f64x2.lt`, [f64x2([1, 1]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7795
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([2, 2]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7798
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([2, 2]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7801
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([2, 2]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7804
+assert_return(() => invoke($0, `f64x2.lt`, [f64x2([2, 2]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7807
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7810
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7813
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7816
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([-1, -1]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7819
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7822
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7825
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7828
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([0, 0]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7831
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7834
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7837
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7840
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([1, 1]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7843
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([2, 2]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7846
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([2, 2]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7849
+assert_return(() => invoke($0, `f64x2.le`, [f64x2([2, 2]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7852
+assert_return(
+  () => invoke($0, `f64x2.le`, [f64x2([2, 2]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7855
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([-1, -1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7858
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7861
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7864
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([-1, -1]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7867
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7870
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7873
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7876
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([0, 0]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7879
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7882
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7885
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7888
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([1, 1]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7891
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([2, 2]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7894
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([2, 2]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7897
+assert_return(
+  () => invoke($0, `f64x2.gt`, [f64x2([2, 2]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7900
+assert_return(() => invoke($0, `f64x2.gt`, [f64x2([2, 2]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7903
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7906
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([0, 0])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7909
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7912
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([-1, -1]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7915
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7918
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7921
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([1, 1])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7924
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([0, 0]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7927
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7930
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7933
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7936
+assert_return(() => invoke($0, `f64x2.ge`, [f64x2([1, 1]), f64x2([2, 2])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7939
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([2, 2]), f64x2([-1, -1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7942
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([2, 2]), f64x2([0, 0])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7945
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([2, 2]), f64x2([1, 1])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7948
+assert_return(
+  () => invoke($0, `f64x2.ge`, [f64x2([2, 2]), f64x2([2, 2])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7954
+assert_malformed(
+  () => instantiate(`(memory 1) (func  (param $$x v128) (param $$y v128) (result v128) (f2x64.eq (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7955
+assert_malformed(
+  () => instantiate(`(memory 1) (func  (param $$x v128) (param $$y v128) (result v128) (f2x64.ne (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7956
+assert_malformed(
+  () => instantiate(`(memory 1) (func  (param $$x v128) (param $$y v128) (result v128) (f2x64.lt (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7957
+assert_malformed(
+  () => instantiate(`(memory 1) (func  (param $$x v128) (param $$y v128) (result v128) (f2x64.le (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7958
+assert_malformed(
+  () => instantiate(`(memory 1) (func  (param $$x v128) (param $$y v128) (result v128) (f2x64.gt (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7959
+assert_malformed(
+  () => instantiate(`(memory 1) (func  (param $$x v128) (param $$y v128) (result v128) (f2x64.ge (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7962
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.eq (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7963
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.ne (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7964
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.lt (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7965
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.le (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7966
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7967
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7971
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.eq-1st-arg-empty (result v128)
+      (f64x2.eq (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7979
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.eq-arg-empty (result v128)
+      (f64x2.eq)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7987
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.ne-1st-arg-empty (result v128)
+      (f64x2.ne (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:7995
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.ne-arg-empty (result v128)
+      (f64x2.ne)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8003
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.lt-1st-arg-empty (result v128)
+      (f64x2.lt (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8011
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.lt-arg-empty (result v128)
+      (f64x2.lt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8019
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.le-1st-arg-empty (result v128)
+      (f64x2.le (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8027
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.le-arg-empty (result v128)
+      (f64x2.le)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8035
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.gt-1st-arg-empty (result v128)
+      (f64x2.gt (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8043
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.gt-arg-empty (result v128)
+      (f64x2.gt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8051
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.ge-1st-arg-empty (result v128)
+      (f64x2.ge (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8059
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.ge-arg-empty (result v128)
+      (f64x2.ge)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8069
+let $1 = instantiate(`(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))
+          )
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8325
+assert_return(() => invoke($1, `f64x2.eq-in-block`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8326
+assert_return(() => invoke($1, `f64x2.ne-in-block`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8327
+assert_return(() => invoke($1, `f64x2.lt-in-block`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8328
+assert_return(() => invoke($1, `f64x2.le-in-block`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8329
+assert_return(() => invoke($1, `f64x2.gt-in-block`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8330
+assert_return(() => invoke($1, `f64x2.ge-in-block`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8331
+assert_return(() => invoke($1, `nested-f64x2.eq`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8332
+assert_return(() => invoke($1, `nested-f64x2.ne`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8333
+assert_return(() => invoke($1, `nested-f64x2.lt`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8334
+assert_return(() => invoke($1, `nested-f64x2.le`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8335
+assert_return(() => invoke($1, `nested-f64x2.gt`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8336
+assert_return(() => invoke($1, `nested-f64x2.ge`, []), []);
+
+// ./test/core/simd/simd_f64x2_cmp.wast:8337
+assert_return(() => invoke($1, `as-param`, []), []);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js
new file mode 100644
index 0000000000..fc2d068e25
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_pmin_pmax.wast.js
@@ -0,0 +1,64564 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:12
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:15
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:18
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:21
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:24
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:27
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:30
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:33
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:36
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:39
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:42
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:45
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:48
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:51
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:54
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:57
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:60
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:63
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:66
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:69
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0, 0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:72
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:75
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:78
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:81
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:84
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:87
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:90
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:93
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:96
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:99
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:102
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:105
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:108
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:111
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:114
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:117
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:120
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:123
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:126
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:129
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:132
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:135
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:138
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:141
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:144
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:147
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:150
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:153
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:156
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:159
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:162
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:165
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:168
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:171
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:174
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:177
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:180
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:183
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:186
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:189
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0, -0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:192
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:195
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:198
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:201
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:204
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:207
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:210
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:213
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:216
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:219
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:222
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:225
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:228
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:231
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:234
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:237
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:240
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:243
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:246
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:249
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:252
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:255
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:258
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:261
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:264
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:267
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:270
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:273
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:276
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:279
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:282
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:285
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:288
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:291
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:294
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:297
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:300
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:303
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:306
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:309
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:312
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:315
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:318
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:321
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:324
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:327
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:330
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:333
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:336
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:339
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:342
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:345
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:348
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:351
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:354
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:357
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:360
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:363
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:366
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:369
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:372
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:375
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:378
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:381
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:384
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:387
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:390
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:393
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:396
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:399
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:402
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:405
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:408
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:411
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:414
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:417
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:420
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:423
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:426
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:429
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:432
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:435
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:438
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:441
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:444
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:447
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:450
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:453
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:456
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:459
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:462
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:465
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:468
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:471
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:474
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:477
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:480
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:483
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:486
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:489
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:492
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:495
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:498
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:501
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:504
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:507
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:510
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:513
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:516
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:519
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:522
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:525
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:528
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:531
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:534
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:537
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:540
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:543
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:546
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:549
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([0.5, 0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:552
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:555
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:558
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:561
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:564
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:567
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:570
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:573
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:576
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:579
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:582
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:585
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:588
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:591
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:594
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:597
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:600
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:603
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:606
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:609
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:612
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:615
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:618
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:621
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:624
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:627
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:630
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:633
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:636
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:639
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:642
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:645
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:648
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:651
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:654
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:657
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:660
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:663
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:666
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:669
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-0.5, -0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:672
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:675
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:678
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:681
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:684
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:687
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:690
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:693
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:696
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:699
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:702
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:705
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:708
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:711
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:714
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:717
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:720
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:723
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:726
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:729
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:732
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:735
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:738
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:741
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:744
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:747
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:750
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:753
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:756
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:759
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:762
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:765
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:768
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:771
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:774
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:777
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:780
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:783
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:786
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:789
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([1, 1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:792
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:795
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:798
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:801
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:804
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:807
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:810
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:813
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:816
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:819
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:822
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:825
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:828
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:831
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:834
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:837
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:840
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:843
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:846
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:849
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:852
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:855
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:858
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:861
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:864
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:867
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:870
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:873
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:876
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:879
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:882
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:885
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:888
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:891
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:894
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:897
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:900
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:903
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:906
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:909
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-1, -1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:912
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:915
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:918
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:921
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:924
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:927
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:930
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:933
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:936
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:939
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:942
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:945
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:948
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:951
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:954
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:957
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:960
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:963
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:966
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:969
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:972
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:975
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:978
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:981
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:984
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:987
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:990
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:993
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:996
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:999
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1002
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1005
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1008
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1011
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1014
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1017
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1020
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1023
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1026
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1029
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1032
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1035
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1038
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1041
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1044
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1047
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1050
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1053
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1056
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1059
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1062
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1065
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1068
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1071
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1074
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1077
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1080
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1083
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1086
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1089
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1092
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1095
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1098
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1101
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1104
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1107
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1110
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1113
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1116
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1119
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1122
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1125
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1128
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1131
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1134
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1137
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1140
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1143
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1146
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1149
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1152
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1155
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1158
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1161
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1164
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1167
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1170
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1173
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1176
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1179
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1182
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1185
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1188
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1191
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1194
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1197
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1200
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1203
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1206
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1209
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1212
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1215
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1218
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1221
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1224
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1227
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1230
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1233
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1236
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1239
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1242
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1245
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1248
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1251
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1254
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1257
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1260
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1263
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1266
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1269
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1272
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1275
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1278
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1281
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1284
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1287
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1290
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1293
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1296
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1299
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1302
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1305
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1308
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1311
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1314
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1317
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1320
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1323
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1326
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1329
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1332
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1335
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1338
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1341
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1344
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1347
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1350
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1353
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1356
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1359
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1362
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1365
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1368
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1371
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1374
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1377
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1380
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1383
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1386
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1389
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1392
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1395
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1398
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1401
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1404
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1407
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1410
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1413
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1416
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1419
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1422
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1425
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1428
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1431
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1434
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1437
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1440
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1443
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1446
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1449
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1452
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1455
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1458
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1461
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1464
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1467
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1470
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1473
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1476
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1479
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1482
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1485
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1488
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1491
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1494
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1497
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1500
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1503
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1506
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1509
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1512
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1515
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1518
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1521
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1524
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1527
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1530
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1533
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1536
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1539
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1542
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1545
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1548
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1551
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1554
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1557
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1560
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1563
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1566
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1569
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1572
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1575
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1578
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1581
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1584
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1587
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1590
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1593
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1596
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1599
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1602
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1605
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1608
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1611
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1614
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1617
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1620
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1623
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1626
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1629
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1632
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1635
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1638
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1641
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1644
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1647
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1650
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1653
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1656
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1659
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1662
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1665
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1668
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1671
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1674
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1677
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1680
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1683
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1686
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1689
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1692
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1695
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1698
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1701
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1704
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1707
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1710
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1713
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1716
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1719
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1722
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1725
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1728
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1731
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1734
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1737
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1740
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1743
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1746
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1749
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1752
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1755
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1758
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1761
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1764
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1767
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1770
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1773
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1776
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1779
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1782
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1785
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1788
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1791
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1794
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1797
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1800
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1803
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1806
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1809
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1812
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1815
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1818
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1821
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1824
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1827
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1830
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1833
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1836
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1839
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1842
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1845
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1848
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1851
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1854
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1857
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1860
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1863
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1866
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1869
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1872
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1875
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1878
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1881
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1884
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1887
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1890
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1893
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1896
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1899
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1902
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1905
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1908
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1911
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1914
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1917
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1920
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1923
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1926
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1929
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1932
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1935
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1938
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1941
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1944
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1947
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1950
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1953
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1956
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1959
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1962
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1965
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1968
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1971
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1974
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1977
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1980
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1983
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1986
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1989
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1992
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1995
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:1998
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2001
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2004
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2007
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2010
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2013
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2016
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2019
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2022
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2025
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2028
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2031
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2034
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2037
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2040
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2043
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2046
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2049
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2052
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2055
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2058
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2061
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2064
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2067
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2070
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2073
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2076
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2079
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2082
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2085
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2088
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2091
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2094
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2097
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2100
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2103
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2106
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2109
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2112
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2115
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2118
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2121
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2124
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2127
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2130
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2133
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2136
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2139
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2142
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2145
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2148
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2151
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2154
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2157
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2160
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2163
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2166
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2169
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2172
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2175
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2178
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2181
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2184
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2187
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2190
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2193
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2196
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2199
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2202
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2205
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2208
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2211
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2214
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2217
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2220
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2223
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2226
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2229
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2232
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2235
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2238
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2241
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2244
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2247
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2250
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2253
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2256
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2259
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2262
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2265
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2268
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2271
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2274
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2277
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2280
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2283
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2286
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2289
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2292
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2295
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2298
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2301
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2304
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2307
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2310
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2313
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2316
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2319
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2322
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2325
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2328
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2331
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2334
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2337
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2340
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2343
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2346
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2349
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2352
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2355
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2358
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2361
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2364
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2367
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2370
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2373
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2376
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2379
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2382
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2385
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2388
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2391
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2394
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2397
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2400
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2403
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2406
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2409
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2412
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2415
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2418
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2421
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2424
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2427
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2430
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [f64x2([123456789, 123456789]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2433
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2436
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2439
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2442
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2445
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2448
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2451
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2454
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2457
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2460
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2463
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2466
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2469
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2472
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2475
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2478
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2481
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2484
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2487
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2490
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2493
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2496
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2499
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2502
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2505
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2508
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2511
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2514
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2517
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2520
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2523
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2526
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2529
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2532
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2535
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2538
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2541
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2544
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2547
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2550
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2553
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2556
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2559
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2562
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2565
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2568
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2571
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2574
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2577
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2580
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2583
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2586
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2589
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2592
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2595
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2598
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2601
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2604
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2607
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2610
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2613
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2616
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2619
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2622
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2625
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2628
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2631
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2634
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2637
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2640
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2643
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2646
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2649
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2652
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2655
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2658
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2661
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2664
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2667
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2670
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2673
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2676
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2679
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2682
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2685
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2688
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2691
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2694
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2697
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2700
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2703
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2706
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2709
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2712
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2715
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2718
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2721
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2724
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2727
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2730
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2733
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2736
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2739
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2742
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2745
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2748
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2751
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2754
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2757
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2760
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2763
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2766
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2769
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2772
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2775
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2778
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2781
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2784
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2787
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2790
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2793
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2796
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2799
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2802
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2805
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2808
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2811
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2814
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2817
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2820
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2823
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2826
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2829
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2832
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2835
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2838
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2841
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2844
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2847
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2850
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2853
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2856
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2859
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2862
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2865
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2868
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2871
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2874
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2877
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2880
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2883
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2886
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2889
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2892
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2895
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2898
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2901
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2904
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2907
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2910
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2913
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2916
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2919
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2922
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2925
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2928
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2931
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2934
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2937
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2940
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2943
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2946
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2949
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2952
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2955
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2958
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2961
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2964
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2967
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2970
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2973
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2976
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2979
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2982
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2985
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2988
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2991
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2994
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:2997
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3000
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3003
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3006
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3009
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3012
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3015
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3018
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3021
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3024
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3027
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3030
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3033
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3036
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3039
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3042
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3045
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3048
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3051
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3054
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3057
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3060
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3063
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3066
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3069
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3072
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3075
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3078
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3081
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3084
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3087
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3090
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3093
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3096
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3099
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3102
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3105
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3108
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3111
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3114
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3117
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3120
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3123
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3126
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3129
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3132
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3135
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3138
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3141
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3144
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3147
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3150
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3153
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3156
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3159
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3162
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3165
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3168
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3171
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3174
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3177
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3180
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3183
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3186
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3189
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3192
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3195
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3198
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3201
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3204
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3207
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3210
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3213
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3216
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3219
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3222
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3225
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3228
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3231
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3234
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3237
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3240
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3243
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3246
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3249
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3252
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3255
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3258
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3261
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3264
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3267
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3270
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3273
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3276
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3279
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3282
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3285
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3288
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3291
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3294
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3297
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3300
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3303
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3306
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3309
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3312
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3315
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3318
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3321
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3324
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3327
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3330
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3333
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3336
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3339
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3342
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3345
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3348
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3351
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3354
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3357
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3360
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3363
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3366
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3369
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3372
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3375
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3378
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3381
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3384
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3387
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3390
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3393
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3396
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3399
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3402
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3405
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3408
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3411
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3414
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3417
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3420
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3423
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3426
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3429
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3432
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3435
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3438
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3441
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3444
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3447
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3450
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3453
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3456
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3459
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3462
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3465
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3468
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3471
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3474
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3477
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3480
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3483
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3486
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3489
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3492
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3495
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3498
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3501
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3504
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3507
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3510
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3513
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3516
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3519
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3522
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3525
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3528
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3531
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3534
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3537
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3540
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3543
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3546
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3549
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3552
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3555
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3558
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3561
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3564
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3567
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3570
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3573
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3576
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3579
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3582
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3585
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3588
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3591
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3594
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3597
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3600
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3603
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3606
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3609
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3612
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3615
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3618
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3621
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3624
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3627
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3630
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3633
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3636
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3639
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3642
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3645
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3648
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3651
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3654
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3657
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3660
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3663
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3666
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3669
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3672
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3675
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3678
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3681
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3684
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3687
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3690
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3693
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3696
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3699
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3702
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3705
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3708
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3711
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3714
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3717
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3720
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3723
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3726
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3729
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3732
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3735
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3738
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3741
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3744
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3747
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3750
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3753
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3756
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3759
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3762
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3765
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3768
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3771
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3774
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3777
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3780
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3783
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3786
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3789
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3792
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3795
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3798
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3801
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3804
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3807
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3810
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3813
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3816
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3819
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3822
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3825
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3828
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3831
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3834
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3837
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3840
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3843
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3846
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3849
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3852
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3855
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3858
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3861
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3864
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3867
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3870
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3873
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3876
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3879
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3882
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3885
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3888
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3891
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3894
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3897
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3900
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3903
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3906
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3909
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3912
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3915
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3918
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3921
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3924
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3927
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3930
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3933
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3936
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3939
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3942
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3945
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3948
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3951
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3954
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3957
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3960
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3963
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3966
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3969
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3972
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3975
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3978
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3981
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3984
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3987
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3990
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3993
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3996
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:3999
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4002
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4005
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4008
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4011
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4014
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4017
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4020
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4023
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4026
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4029
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4032
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4035
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4038
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4041
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4044
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4047
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4050
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4053
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4056
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4059
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4062
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4065
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4068
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4071
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4074
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4077
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4080
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4083
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4086
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4089
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4092
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4095
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4098
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4101
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4104
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4107
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4110
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4113
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4116
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4119
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4122
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4125
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4128
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4131
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4134
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4137
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4140
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4143
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4146
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4149
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4152
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4155
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4158
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4161
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4164
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4167
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4170
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4173
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4176
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4179
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4182
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4185
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4188
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4191
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4194
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4197
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4200
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4203
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4206
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4209
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4212
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4215
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4218
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4221
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4224
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4227
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4230
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4233
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4236
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4239
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4242
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4245
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4248
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4251
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4254
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4257
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4260
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4263
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4266
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4269
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4272
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4275
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4278
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4281
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4284
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4287
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4290
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4293
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4296
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4299
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4302
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4305
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4308
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4311
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4314
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4317
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4320
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4323
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4326
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4329
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4332
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4335
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4338
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4341
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4344
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4347
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4350
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4353
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4356
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4359
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4362
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4365
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4368
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4371
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4374
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4377
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4380
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4383
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4386
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4389
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4392
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4395
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4398
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4401
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4404
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4407
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4410
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4413
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4416
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4419
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4422
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4425
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4428
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4431
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4434
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4437
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4440
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4443
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4446
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4449
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4452
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4455
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4458
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4461
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4464
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4467
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4470
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4473
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4476
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4479
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4482
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4485
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4488
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4491
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4494
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4497
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4500
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4503
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4506
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4509
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4512
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4515
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4518
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4521
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4524
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4527
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4530
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4533
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4536
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4539
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4542
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4545
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4548
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4551
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4554
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4557
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4560
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4563
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4566
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4569
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4572
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4575
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4578
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4581
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4584
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4587
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4590
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4593
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4596
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4599
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4602
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4605
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4608
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4611
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4614
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4617
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4620
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4623
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4626
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4629
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4632
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4635
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4638
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4641
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4644
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4647
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4650
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4653
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4656
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4659
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4662
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4665
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4668
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4671
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4674
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4677
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4680
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4683
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4686
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4689
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4692
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4695
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4698
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4701
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4704
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4707
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4710
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4713
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4716
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4719
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4722
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4725
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4728
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4731
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4734
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4737
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4740
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4743
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4746
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4749
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4752
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4755
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4758
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4761
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4764
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4767
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4770
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4773
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4776
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4779
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4782
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4785
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4788
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4791
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4794
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4797
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4800
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4803
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4806
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4809
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4812
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4815
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4818
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4821
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4824
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4827
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4830
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4833
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4836
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4839
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4842
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4845
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4848
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4851
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4854
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4857
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4860
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4863
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4866
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4869
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4872
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4875
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4878
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4881
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4884
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4887
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4890
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4893
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4896
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4899
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4902
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4905
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4908
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4911
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4914
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4917
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4920
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4923
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4926
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4929
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4932
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4935
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4938
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4941
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4944
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4947
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4950
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4953
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4956
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4959
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4962
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4965
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4968
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4971
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4974
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4977
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4980
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4983
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4986
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4989
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4992
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4995
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:4998
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5001
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5004
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5007
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5010
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5013
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5016
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5019
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5022
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5025
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5028
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5031
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5034
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5037
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5040
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5043
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5046
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5049
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5052
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5055
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5058
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5061
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5064
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5067
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5070
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5073
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5076
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5079
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5082
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5085
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5088
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5091
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5094
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5097
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5100
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5103
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5106
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5109
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5112
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5115
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5118
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5121
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5124
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5127
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5130
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5133
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5136
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5139
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5142
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5145
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5148
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5151
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5154
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5157
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5160
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5163
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5166
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5169
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5172
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5175
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5178
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5181
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5184
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5187
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5190
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5193
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5196
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5199
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5202
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5205
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5208
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5211
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5214
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5217
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5220
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5223
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5226
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5229
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5232
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5235
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5238
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5241
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5244
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5247
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5250
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5253
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5256
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5259
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5262
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5265
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5268
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5271
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5274
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5277
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5280
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5283
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5286
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5289
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5292
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5295
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5298
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5301
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5304
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5307
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5310
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5313
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5316
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5319
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5322
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5325
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5328
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5331
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5334
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5337
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5340
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5343
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5346
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5349
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5352
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5355
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5358
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5361
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5364
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5367
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5370
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5373
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5376
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5379
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5382
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5385
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5388
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5391
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5394
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5397
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5400
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5403
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5406
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5409
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5412
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5415
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5418
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5421
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5424
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5427
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5430
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5433
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5436
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5439
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5442
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5445
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5448
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5451
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5454
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5457
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5460
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5463
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5466
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5469
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5472
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5475
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5478
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5481
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5484
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5487
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5490
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5493
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5496
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5499
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5502
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5505
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5508
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5511
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5514
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5517
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5520
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5523
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5526
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5529
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5532
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5535
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5538
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5541
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5544
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5547
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5550
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5553
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5556
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5559
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5562
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5565
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5568
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5571
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5574
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5577
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5580
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5583
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5586
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5589
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5592
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5595
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5598
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5601
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5604
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5607
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5610
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5613
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5616
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5619
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5622
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5625
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5628
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5631
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5634
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5637
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5640
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5643
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5646
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5649
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5652
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5655
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5658
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5661
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5664
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5667
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5670
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5673
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5676
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5679
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5682
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5685
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5688
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5691
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5694
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5697
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5700
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5703
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5706
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5709
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5712
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5715
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5718
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5721
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5724
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5727
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5730
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5733
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5736
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5739
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5742
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5745
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5748
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5751
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5754
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5757
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5760
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5763
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5766
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5769
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5772
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5775
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5778
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5781
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5784
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5787
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5790
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5793
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5796
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5799
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5802
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5805
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5808
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5811
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5814
+assert_return(
+  () => invoke($0, `f64x2.pmin`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5817
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5820
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5823
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5826
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5829
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5832
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5835
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5838
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5841
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5844
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5847
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5850
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5853
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5856
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5859
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5862
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5865
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5868
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5871
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5874
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5877
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0, 0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5880
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5883
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5886
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5889
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5892
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5895
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5898
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5901
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5904
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5907
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5910
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5913
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5916
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5919
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5922
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5925
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5928
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5931
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5934
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5937
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5940
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5943
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5946
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5949
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5952
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5955
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5958
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5961
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5964
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5967
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5970
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5973
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5976
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5979
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5982
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5985
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5988
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5991
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5994
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:5997
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0, -0]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6000
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6003
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6006
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6009
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6012
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6015
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6018
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6021
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6024
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6027
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6030
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6033
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6036
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6039
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6042
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6045
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6048
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6051
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6054
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6057
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6060
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6063
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6066
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6069
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6072
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6075
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6078
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6081
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6084
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6087
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6090
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6093
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6096
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6099
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6102
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6105
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6108
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6111
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6114
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6117
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6120
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6123
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6126
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6129
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6132
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6135
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6138
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6141
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6144
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6147
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6150
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6153
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6156
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6159
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6162
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6165
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6168
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6171
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6174
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6177
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6180
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6183
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6186
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6189
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6192
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6195
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6198
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6201
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6204
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6207
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6210
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6213
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6216
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6219
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6222
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6225
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6228
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6231
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6234
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6237
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6240
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6243
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6246
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6249
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6252
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6255
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6258
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6261
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6264
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6267
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6270
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6273
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6276
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6279
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6282
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6285
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6288
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6291
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6294
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6297
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6300
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6303
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6306
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6309
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6312
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6315
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6318
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6321
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6324
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6327
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6330
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6333
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6336
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6339
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6342
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6345
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6348
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6351
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6354
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6357
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([0.5, 0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6360
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6363
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6366
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6369
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6372
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6375
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6378
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6381
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6384
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6387
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6390
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6393
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6396
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6399
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6402
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6405
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6408
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6411
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6414
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6417
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6420
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6423
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6426
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6429
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6432
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6435
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6438
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6441
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6444
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6447
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6450
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6453
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6456
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6459
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6462
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6465
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6468
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6471
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6474
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6477
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-0.5, -0.5]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6480
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6483
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6486
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6489
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6492
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6495
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6498
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6501
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6504
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6507
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6510
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6513
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6516
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6519
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6522
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6525
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6528
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6531
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6534
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6537
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6540
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6543
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6546
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6549
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6552
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6555
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6558
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6561
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6564
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6567
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6570
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6573
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6576
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6579
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6582
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6585
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6588
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6591
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6594
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6597
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([1, 1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6600
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6603
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6606
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6609
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6612
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6615
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6618
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6621
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6624
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6627
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6630
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6633
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6636
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6639
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6642
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6645
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6648
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6651
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6654
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6657
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6660
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6663
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6666
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6669
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6672
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6675
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6678
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6681
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6684
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6687
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6690
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6693
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6696
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6699
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6702
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6705
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6708
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6711
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6714
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6717
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-1, -1]), f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6720
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6723
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6726
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6729
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6732
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6735
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6738
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6741
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6744
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6747
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6750
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6753
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6756
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6759
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6762
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6765
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6768
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6771
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6774
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6777
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6780
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6783
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6786
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6789
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6792
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6795
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6798
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6801
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6804
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6807
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6810
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6813
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6816
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6819
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6822
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6825
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6828
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6831
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6834
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6837
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6840
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6843
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6846
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6849
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6852
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6855
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6858
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6861
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6864
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6867
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6870
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6873
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6876
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6879
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6882
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6885
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6888
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6891
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6894
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6897
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6900
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6903
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6906
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6909
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6912
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6915
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6918
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6921
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6924
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6927
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6930
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6933
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6936
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6939
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6942
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6945
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6948
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6951
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6954
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6957
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6960
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6963
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6966
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6969
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6972
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6975
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6978
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6981
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6984
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6987
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6990
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6993
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6996
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:6999
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7002
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7005
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7008
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7011
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7014
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7017
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7020
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7023
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7026
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7029
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7032
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7035
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7038
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7041
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7044
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7047
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7050
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7053
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7056
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7059
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7062
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7065
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7068
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7071
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7074
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7077
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7080
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7083
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7086
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7089
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7092
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7095
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7098
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7101
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7104
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7107
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7110
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7113
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7116
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7119
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7122
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7125
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7128
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7131
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7134
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7137
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7140
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7143
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7146
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7149
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7152
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7155
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7158
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7161
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7164
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7167
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7170
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7173
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7176
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7179
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7182
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7185
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7188
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7191
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7194
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7197
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7200
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7203
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7206
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7209
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7212
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7215
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7218
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7221
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7224
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7227
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7230
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7233
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7236
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7239
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7242
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7245
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7248
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7251
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7254
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7257
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7260
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7263
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7266
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7269
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7272
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7275
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7278
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7281
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7284
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7287
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7290
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7293
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7296
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7299
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7302
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7305
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7308
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7311
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7314
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7317
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7320
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7323
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7326
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7329
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7332
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7335
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7338
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7341
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7344
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7347
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7350
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7353
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7356
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7359
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7362
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7365
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7368
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7371
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7374
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7377
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7380
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7383
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7386
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7389
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7392
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7395
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7398
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7401
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7404
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7407
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7410
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7413
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7416
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7419
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7422
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7425
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7428
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7431
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7434
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7437
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7440
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7443
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7446
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7449
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7452
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7455
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7458
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7461
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7464
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7467
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7470
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7473
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7476
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7479
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7482
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7485
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7488
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7491
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7494
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7497
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([Infinity, Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7500
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([Infinity, Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7503
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7506
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7509
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([Infinity, Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7512
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([Infinity, Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7515
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([Infinity, Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7518
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([Infinity, Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7521
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7524
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7527
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7530
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7533
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7536
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7539
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7542
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7545
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7548
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7551
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7554
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7557
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7560
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7563
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7566
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7569
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7572
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7575
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7578
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7581
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7584
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7587
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7590
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7593
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7596
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7599
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7602
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7605
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7608
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7611
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7614
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7617
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-Infinity, -Infinity]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7620
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-Infinity, -Infinity]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7623
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7626
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7629
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-Infinity, -Infinity]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7632
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-Infinity, -Infinity]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7635
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-Infinity, -Infinity]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7638
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([-Infinity, -Infinity]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7641
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7644
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7647
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7650
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7653
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7656
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7659
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7662
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7665
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7668
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7671
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7674
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7677
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7680
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7683
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7686
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7689
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7692
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7695
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7698
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7701
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7704
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7707
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7710
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7713
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7716
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7719
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7722
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7725
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7728
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7731
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7734
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7737
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7740
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7743
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7746
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7749
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7752
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7755
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7758
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7761
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7764
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7767
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7770
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7773
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7776
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7779
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7782
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7785
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7788
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7791
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7794
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7797
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7800
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7803
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7806
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7809
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7812
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7815
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7818
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7821
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7824
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7827
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7830
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7833
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7836
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7839
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7842
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7845
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7848
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7851
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7854
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7857
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7860
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7863
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7866
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7869
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7872
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7875
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7878
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7881
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7884
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7887
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7890
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7893
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7896
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7899
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7902
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7905
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7908
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7911
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7914
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7917
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7920
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7923
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7926
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7929
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7932
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7935
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7938
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7941
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7944
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7947
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7950
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7953
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7956
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7959
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7962
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7965
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7968
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7971
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7974
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7977
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7980
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7983
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7986
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7989
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7992
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7995
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:7998
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8001
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8004
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8007
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8010
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8013
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8016
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8019
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8022
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8025
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8028
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8031
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8034
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8037
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8040
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8043
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8046
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8049
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8052
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8055
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8058
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8061
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8064
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8067
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8070
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8073
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8076
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8079
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8082
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8085
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8088
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8091
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8094
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8097
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8100
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8103
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8106
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8109
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8112
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8115
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8118
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8121
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8124
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8127
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8130
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8133
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8136
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8139
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8142
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8145
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8148
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8151
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8154
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8157
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8160
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8163
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8166
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8169
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8172
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8175
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8178
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8181
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8184
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8187
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8190
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8193
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8196
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8199
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8202
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8205
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8208
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8211
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8214
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8217
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8220
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8223
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8226
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8229
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8232
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8235
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8238
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [f64x2([123456789, 123456789]), f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8241
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8244
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8247
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8250
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8253
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8256
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8259
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8262
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8265
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8268
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8271
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8274
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8277
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8280
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8283
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8286
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8289
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8292
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8295
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8298
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8301
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8304
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8307
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8310
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8313
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8316
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8319
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8322
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8325
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8328
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8331
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8334
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8337
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8340
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8343
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8346
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8349
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8352
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8355
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8358
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8361
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8364
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8367
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8370
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8373
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8376
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8379
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8382
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8385
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8388
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8391
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8394
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8397
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8400
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8403
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8406
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8409
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8412
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8415
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8418
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8421
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8424
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8427
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8430
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8433
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8436
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8439
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8442
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8445
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8448
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8451
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8454
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8457
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8460
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8463
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8466
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8469
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8472
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8475
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8478
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8481
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8484
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8487
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8490
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8493
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8496
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8499
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8502
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8505
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8508
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8511
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8514
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8517
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8520
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8523
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8526
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8529
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8532
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8535
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8538
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8541
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8544
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8547
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8550
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8553
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8556
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8559
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8562
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8565
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8568
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8571
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8574
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8577
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8580
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8583
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8586
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8589
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8592
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8595
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8598
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8601
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8604
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8607
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8610
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8613
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8616
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8619
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8622
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8625
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8628
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8631
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8634
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8637
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8640
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8643
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8646
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8649
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8652
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8655
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8658
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8661
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8664
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8667
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8670
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8673
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8676
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8679
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8682
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8685
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8688
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8691
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8694
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8697
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8700
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8703
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8706
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8709
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8712
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8715
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8718
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8721
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8724
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8727
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8730
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8733
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8736
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8739
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8742
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8745
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8748
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8751
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8754
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8757
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8760
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8763
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8766
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8769
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8772
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8775
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8778
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8781
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8784
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8787
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8790
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8793
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8796
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8799
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8802
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8805
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8808
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8811
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8814
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8817
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8820
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8823
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8826
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8829
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8832
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8835
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8838
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8841
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8844
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8847
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8850
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8853
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8856
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8859
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8862
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8865
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8868
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8871
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8874
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8877
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8880
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8883
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8886
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8889
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8892
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8895
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8898
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8901
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8904
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8907
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8910
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8913
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8916
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8919
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8922
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8925
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8928
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8931
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8934
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8937
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8940
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8943
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8946
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8949
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8952
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8955
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8958
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8961
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8964
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8967
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8970
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8973
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8976
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8979
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8982
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8985
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8988
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8991
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8994
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:8997
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9000
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9003
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9006
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9009
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9012
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9015
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9018
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9021
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9024
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9027
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9030
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9033
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9036
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9039
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9042
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9045
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9048
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9051
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9054
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9057
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9060
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9063
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9066
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9069
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9072
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9075
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1, 1]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9078
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9081
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9084
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9087
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9090
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9093
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9096
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9099
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9102
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9105
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9108
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9111
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9114
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9117
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9120
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9123
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9126
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9129
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9132
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9135
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9138
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9141
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9144
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9147
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9150
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9153
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9156
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9159
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9162
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9165
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9168
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9171
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9174
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9177
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9180
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9183
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9186
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9189
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9192
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9195
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9198
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9201
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9204
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9207
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9210
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9213
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9216
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9219
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9222
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9225
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9228
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9231
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9234
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9237
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9240
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9243
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9246
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9249
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9252
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9255
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9258
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9261
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9264
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9267
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9270
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9273
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9276
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9279
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9282
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9285
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9288
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9291
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9294
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9297
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9300
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9303
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9306
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9309
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9312
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9315
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9318
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9321
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9324
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9327
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9330
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9333
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9336
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9339
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9342
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9345
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9348
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9351
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9354
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9357
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9360
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9363
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9366
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9369
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9372
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9375
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9378
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9381
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9384
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9387
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9390
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9393
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9396
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9399
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9402
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9405
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9408
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9411
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9414
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9417
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9420
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9423
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9426
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9429
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9432
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9435
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9438
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9441
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9444
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9447
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9450
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9453
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9456
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9459
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9462
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9465
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9468
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9471
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9474
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9477
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9480
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9483
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9486
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9489
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9492
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9495
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9498
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9501
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9504
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9507
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9510
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9513
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9516
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9519
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9522
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9525
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9528
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9531
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9534
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9537
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9540
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9543
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9546
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9549
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9552
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9555
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9558
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9561
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9564
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9567
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9570
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9573
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9576
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9579
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9582
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9585
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9588
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9591
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9594
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9597
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9600
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9603
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9606
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9609
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9612
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9615
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9618
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9621
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9624
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9627
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9630
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9633
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9636
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9639
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9642
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9645
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9648
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9651
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9654
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9657
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9660
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9663
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9666
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9669
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9672
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9675
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9678
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9681
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9684
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9687
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9690
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9693
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9696
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9699
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9702
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9705
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9708
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9711
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9714
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9717
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9720
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9723
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9726
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9729
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9732
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9735
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9738
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9741
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9744
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9747
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9750
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9753
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9756
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9759
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9762
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9765
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9768
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9771
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9774
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9777
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9780
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9783
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9786
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9789
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9792
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9795
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9798
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9801
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9804
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9807
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9810
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9813
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9816
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9819
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9822
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9825
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9828
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9831
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9834
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9837
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9840
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9843
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9846
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9849
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9852
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9855
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9858
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9861
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9864
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9867
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9870
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9873
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9876
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9879
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9882
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9885
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9888
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9891
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9894
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9897
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9900
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9903
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9906
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9909
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9912
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9915
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9918
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9921
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9924
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9927
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9930
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9933
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9936
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9939
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9942
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9945
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9948
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9951
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9954
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9957
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9960
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9963
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9966
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9969
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9972
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9975
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9978
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9981
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9984
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9987
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9990
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9993
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9996
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:9999
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10002
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10005
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10008
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10011
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10014
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10017
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10020
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10023
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10026
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10029
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10032
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10035
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10038
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10041
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10044
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10047
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10050
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10053
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10056
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10059
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10062
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10065
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10068
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10071
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10074
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10077
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10080
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10083
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10086
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10089
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10092
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10095
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10098
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10101
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10104
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10107
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10110
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10113
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10116
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10119
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10122
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10125
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10128
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10131
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10134
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10137
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10140
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10143
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10146
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10149
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10152
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10155
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10158
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10161
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10164
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10167
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10170
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10173
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10176
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10179
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10182
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10185
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10188
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10191
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10194
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10197
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10200
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10203
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10206
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10209
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10212
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10215
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10218
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10221
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10224
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10227
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10230
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10233
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10236
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10239
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10242
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10245
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10248
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10251
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10254
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10257
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10260
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10263
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10266
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10269
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10272
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10275
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10278
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10281
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10284
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10287
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10290
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10293
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10296
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10299
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10302
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10305
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10308
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10311
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10314
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10317
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10320
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10323
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10326
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10329
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10332
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10335
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10338
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10341
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10344
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10347
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10350
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10353
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10356
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10359
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10362
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10365
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10368
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10371
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10374
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10377
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10380
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10383
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10386
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10389
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10392
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10395
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10398
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10401
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10404
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10407
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10410
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10413
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10416
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10419
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10422
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10425
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10428
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10431
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10434
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10437
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10440
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10443
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10446
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10449
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10452
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10455
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10458
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10461
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10464
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10467
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10470
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10473
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10476
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10479
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10482
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10485
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10488
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10491
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10494
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10497
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10500
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10503
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10506
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10509
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10512
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10515
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10518
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10521
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10524
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10527
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10530
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10533
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10536
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10539
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10542
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10545
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10548
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10551
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10554
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10557
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10560
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10563
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10566
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10569
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10572
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10575
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10578
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10581
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10584
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10587
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10590
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10593
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10596
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10599
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10602
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10605
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10608
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10611
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10614
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10617
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10620
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10623
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10626
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10629
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10632
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10635
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10638
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10641
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10644
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10647
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10650
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10653
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10656
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10659
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10662
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10665
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10668
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10671
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10674
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10677
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10680
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10683
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10686
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10689
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10692
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10695
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10698
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10701
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10704
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10707
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10710
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10713
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10716
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10719
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10722
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10725
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10728
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10731
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10734
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10737
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10740
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10743
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10746
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10749
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10752
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10755
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10758
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10761
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10764
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10767
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10770
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10773
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10776
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10779
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10782
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10785
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10788
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10791
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10794
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10797
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10800
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10803
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10806
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10809
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10812
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10815
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10818
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10821
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10824
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10827
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10830
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10833
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10836
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10839
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10842
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10845
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10848
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10851
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10854
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10857
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10860
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10863
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10866
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10869
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10872
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10875
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10878
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10881
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10884
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10887
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10890
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10893
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10896
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10899
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10902
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10905
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10908
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10911
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10914
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10917
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10920
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10923
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10926
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10929
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10932
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10935
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10938
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10941
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10944
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10947
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10950
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10953
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10956
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10959
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10962
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10965
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10968
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10971
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10974
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10977
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10980
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10983
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10986
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10989
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10992
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10995
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:10998
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11001
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11004
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11007
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11010
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11013
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0, 0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11016
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0, -0]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11019
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11022
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11025
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.5, 0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11028
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-0.5, -0.5]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11031
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1, 1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11034
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-1, -1]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11037
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([6.283185307179586, 6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11040
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-6.283185307179586, -6.283185307179586]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11043
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11046
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11049
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11052
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11055
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([Infinity, Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11058
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([-Infinity, -Infinity]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11061
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11064
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11067
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11070
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11073
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([123456789, 123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11076
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11079
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11082
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11085
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([123456789.01234567, 123456789.01234567]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11088
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11091
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11094
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11097
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11100
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11103
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11106
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11109
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11112
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11115
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11118
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11121
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11124
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11127
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11130
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    f64x2([2623536934927580700, 2623536934927580700]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11133
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11136
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11139
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11142
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11145
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11148
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11151
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11154
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11157
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11160
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11163
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11166
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11169
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11172
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11175
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11178
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11181
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11184
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11187
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11190
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11193
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11196
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11199
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11202
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11205
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11208
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11211
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11214
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11217
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11220
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11223
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11226
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11229
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11232
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11235
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11238
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11241
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11244
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11247
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11250
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11253
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11256
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11259
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11262
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11265
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11268
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11271
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11274
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11277
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11280
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11283
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11286
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11289
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11292
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11295
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11298
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11301
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11304
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11307
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11310
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11313
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11316
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11319
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11322
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11325
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11328
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11331
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11334
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11337
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11340
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11343
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11346
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11349
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11352
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11355
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11358
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11361
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11364
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11367
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11370
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11373
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11376
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11379
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11382
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11385
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11388
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11391
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11394
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11397
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11400
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11403
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11406
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11409
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11412
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11415
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11418
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11421
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11424
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11427
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11430
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11433
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11436
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11439
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11442
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11445
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11448
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11451
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11454
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11457
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11460
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11463
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11466
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11469
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11472
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11475
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11478
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11481
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11484
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11487
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11490
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11493
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11496
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11499
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11502
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11505
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11508
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0, -0]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11511
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11514
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11517
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.5, 0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11520
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-0.5, -0.5]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11523
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1, 1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11526
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-1, -1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11529
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([6.283185307179586, 6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11532
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-6.283185307179586, -6.283185307179586]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11535
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11538
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11541
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11544
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11547
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([Infinity, Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11550
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([-Infinity, -Infinity]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11553
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11556
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11559
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11562
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11565
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789, 123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11568
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11571
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11574
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.0000000000123456789),
+      value("f64", 0.0000000000123456789),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11577
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([123456789.01234567, 123456789.01234567]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 123456789.01234567),
+      value("f64", 123456789.01234567),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11580
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11583
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11586
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000012345678901234568),
+      value("f64", 0.000000000012345678901234568),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11589
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11592
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11595
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11598
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11601
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11604
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11607
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11610
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11613
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11616
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11619
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11622
+assert_return(
+  () => invoke($0, `f64x2.pmax`, [
+    f64x2([2623536934927580700, 2623536934927580700]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11629
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11630
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11631
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11632
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11633
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11634
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11635
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11636
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11639
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.pmin (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11640
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.pmax (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11644
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.pmin-1st-arg-empty (result v128)
+      (f64x2.pmin (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11652
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.pmin-arg-empty (result v128)
+      (f64x2.pmin)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11660
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.pmax-1st-arg-empty (result v128)
+      (f64x2.pmax (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_pmin_pmax.wast:11668
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.pmax-arg-empty (result v128)
+      (f64x2.pmax)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js
new file mode 100644
index 0000000000..c787804bc2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_f64x2_rounding.wast.js
@@ -0,0 +1,2210 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_f64x2_rounding.wast
+
+// ./test/core/simd/simd_f64x2_rounding.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:11
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:13
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:15
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:17
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:19
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:21
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:23
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:25
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:27
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [new F64x2Pattern(value("f64", 7), value("f64", 7))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:29
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [new F64x2Pattern(value("f64", -6), value("f64", -6))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:31
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:33
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:35
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:37
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:39
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:41
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:43
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:45
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:47
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:49
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:51
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:53
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:55
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:57
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:59
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([123456789.01234567, 123456789.01234567])]),
+  [new F64x2Pattern(value("f64", 123456790), value("f64", 123456790))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:61
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:63
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:65
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:67
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:69
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:71
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:73
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:75
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:77
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:79
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:81
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:83
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:85
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:87
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:89
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:91
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:93
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:95
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:97
+assert_return(
+  () => invoke($0, `f64x2.ceil`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:99
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:101
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:103
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:105
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:107
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:109
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:111
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:113
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:115
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [new F64x2Pattern(value("f64", 6), value("f64", 6))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:117
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [new F64x2Pattern(value("f64", -7), value("f64", -7))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:119
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:121
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:123
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:125
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:127
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:129
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:131
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:133
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:135
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:137
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:139
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:141
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:143
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:145
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:147
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([123456789.01234567, 123456789.01234567])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:149
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:151
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:153
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:155
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:157
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:159
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:161
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:163
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:165
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:167
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:169
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:171
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:173
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:175
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:177
+assert_return(
+  () => invoke($0, `f64x2.floor`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:179
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:181
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:183
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:185
+assert_return(
+  () => invoke($0, `f64x2.floor`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:187
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:189
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:191
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:193
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:195
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:197
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:199
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:201
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:203
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [new F64x2Pattern(value("f64", 6), value("f64", 6))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:205
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [new F64x2Pattern(value("f64", -6), value("f64", -6))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:207
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:209
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:211
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:213
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:215
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:217
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:219
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:221
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:223
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:225
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:227
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:229
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:231
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:233
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:235
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([123456789.01234567, 123456789.01234567])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:237
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:239
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:241
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:243
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:245
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:247
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:249
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:251
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:253
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:255
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:257
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:259
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:261
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:263
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:265
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:267
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:269
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:271
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:273
+assert_return(
+  () => invoke($0, `f64x2.trunc`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:275
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([0, 0])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:277
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([-0, -0])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:279
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:281
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:283
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([0.5, 0.5])]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:285
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([-0.5, -0.5])]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:287
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([1, 1])]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:289
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([-1, -1])]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:291
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([6.283185307179586, 6.283185307179586])]),
+  [new F64x2Pattern(value("f64", 6), value("f64", 6))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:293
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([-6.283185307179586, -6.283185307179586])]),
+  [new F64x2Pattern(value("f64", -6), value("f64", -6))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:295
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:297
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:299
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:301
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:303
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([Infinity, Infinity])]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:305
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([-Infinity, -Infinity])]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:307
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:309
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:311
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:313
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:315
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([123456789, 123456789])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:317
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:319
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1234567890000000000000000000, 1234567890000000000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:321
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([0.0000000000123456789, 0.0000000000123456789]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:323
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([123456789.01234567, 123456789.01234567])]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:325
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:327
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1234567890123456900000000000, 1234567890123456900000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890123456900000000000),
+      value("f64", 1234567890123456900000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:329
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([0.000000000012345678901234568, 0.000000000012345678901234568]),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:331
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:333
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:335
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:337
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:339
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:341
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:343
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:345
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:347
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([1375488932539311400000000, 1375488932539311400000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:349
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:351
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    f64x2([721152341463170500000000000000, 721152341463170500000000000000]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:353
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [f64x2([2623536934927580700, 2623536934927580700])]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:355
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:357
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`canonical_nan`, `canonical_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:359
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:361
+assert_return(
+  () => invoke($0, `f64x2.nearest`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf4,
+      0xff,
+    ]),
+  ]),
+  [new F64x2Pattern(`arithmetic_nan`, `arithmetic_nan`)],
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:367
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:368
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:369
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:370
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:371
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:372
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:373
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:374
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:375
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:376
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:377
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:378
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:379
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:380
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:381
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:382
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:385
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.ceil (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:386
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.floor (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:387
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.trunc (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:388
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.nearest (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:392
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.ceil-arg-empty (result v128)
+      (f64x2.ceil)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:400
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.floor-arg-empty (result v128)
+      (f64x2.floor)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:408
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.trunc-arg-empty (result v128)
+      (f64x2.trunc)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_f64x2_rounding.wast:416
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.nearest-arg-empty (result v128)
+      (f64x2.nearest)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js
new file mode 100644
index 0000000000..860294d3a7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith.wast.js
@@ -0,0 +1,1801 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_arith.wast
+
+// ./test/core/simd/simd_i16x8_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_arith.wast:13
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:16
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:19
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:22
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:25
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:28
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:31
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:34
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:37
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:40
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:43
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:46
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:49
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:52
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:55
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:58
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:61
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:64
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:67
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:70
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:73
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:76
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:79
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:82
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:85
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:88
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:91
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:94
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:97
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:100
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:103
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:106
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:109
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:112
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:115
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:118
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:121
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:124
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:127
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i8x16([0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:130
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:133
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i32x4([0x80008000, 0x80008000, 0x80008000, 0x80008000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:136
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:139
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:142
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:145
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i16x8([0x8000, 0xbf80, 0x8000, 0xbf80, 0x8000, 0xbf80, 0x8000, 0xbf80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:148
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i16x8([0x8000, 0x3f80, 0x8000, 0x3f80, 0x8000, 0x3f80, 0x8000, 0x3f80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:151
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x1, 0x7f81, 0x1, 0x7f81, 0x1, 0x7f81, 0x1, 0x7f81])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:154
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x1, 0xff81, 0x1, 0xff81, 0x1, 0xff81, 0x1, 0xff81])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:157
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:160
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:163
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:166
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [i16x8([0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:169
+assert_return(
+  () => invoke($0, `i16x8.add`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678]),
+  ]),
+  [i16x8([0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:174
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:177
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:180
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:183
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:186
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:189
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:192
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:195
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:198
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:201
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:204
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:207
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:210
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:213
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:216
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8003, 0x8003, 0x8003, 0x8003, 0x8003, 0x8003, 0x8003, 0x8003])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:219
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:222
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:225
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:228
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:231
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:234
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:237
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:240
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:243
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:246
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:249
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:252
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:255
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:258
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:261
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:264
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:267
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:270
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:273
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:276
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:279
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:282
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:285
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:288
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i8x16([0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80, 0x0, 0x80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:291
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:294
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i32x4([0x80008000, 0x80008000, 0x80008000, 0x80008000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:297
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:300
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:303
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:306
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i16x8([0x8000, 0x4080, 0x8000, 0x4080, 0x8000, 0x4080, 0x8000, 0x4080])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:309
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i16x8([0x8000, 0xc080, 0x8000, 0xc080, 0x8000, 0xc080, 0x8000, 0xc080])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:312
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x1, 0x8081, 0x1, 0x8081, 0x1, 0x8081, 0x1, 0x8081])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:315
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x1, 0x81, 0x1, 0x81, 0x1, 0x81, 0x1, 0x81])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:318
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x8041, 0x1, 0x8041, 0x1, 0x8041, 0x1, 0x8041])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:321
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:324
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:327
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0xad9c, 0xad9c, 0xad9c, 0xad9c, 0xad9c, 0xad9c, 0xad9c, 0xad9c])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:330
+assert_return(
+  () => invoke($0, `i16x8.sub`, [
+    i16x8([0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444, 0x4444])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:335
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:338
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:341
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:344
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:347
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:350
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:353
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:356
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:359
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:362
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:365
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:368
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:371
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:374
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:377
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:380
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:383
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:386
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:389
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:392
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:395
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:398
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:401
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:404
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:407
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:410
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:413
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:416
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:419
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:422
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:425
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:428
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:431
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:434
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:437
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:440
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:443
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:446
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:449
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000]),
+    i8x16([0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:452
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:455
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i32x4([0x20002, 0x20002, 0x20002, 0x20002]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:458
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:461
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:464
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:467
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:470
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:473
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x0, 0x7f80, 0x0, 0x7f80, 0x0, 0x7f80, 0x0, 0x7f80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:476
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x0, 0xff80, 0x0, 0xff80, 0x0, 0xff80, 0x0, 0xff80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:479
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x0, 0x7fc0, 0x0, 0x7fc0, 0x0, 0x7fc0, 0x0, 0x7fc0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:482
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0xffff, 0xfffc, 0xfff7, 0xfff0, 0xffe7, 0xffdc, 0xffcf])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:485
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x2, 0x8, 0x12, 0x20, 0x32, 0x48, 0x62])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:488
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [i16x8([0x546d, 0x546d, 0x546d, 0x546d, 0x546d, 0x546d, 0x546d, 0x546d])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:491
+assert_return(
+  () => invoke($0, `i16x8.mul`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef]),
+  ]),
+  [i16x8([0xa28c, 0xa28c, 0xa28c, 0xa28c, 0xa28c, 0xa28c, 0xa28c, 0xa28c])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:496
+assert_return(
+  () => invoke($0, `i16x8.neg`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:498
+assert_return(
+  () => invoke($0, `i16x8.neg`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:500
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:502
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:504
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:506
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:508
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:510
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:512
+assert_return(
+  () => invoke($0, `i16x8.neg`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:514
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:516
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:518
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:520
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:522
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:524
+assert_return(
+  () => invoke($0, `i16x8.neg`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:528
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.neg (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:529
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.add (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:530
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:531
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:535
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.neg-arg-empty (result v128)
+      (i16x8.neg)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:543
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.add-1st-arg-empty (result v128)
+      (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:551
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.add-arg-empty (result v128)
+      (i16x8.add)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:559
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.sub-1st-arg-empty (result v128)
+      (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:567
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.sub-arg-empty (result v128)
+      (i16x8.sub)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:575
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.mul-1st-arg-empty (result v128)
+      (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:583
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.mul-arg-empty (result v128)
+      (i16x8.mul)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:593
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_arith.wast:610
+assert_return(
+  () => invoke($1, `add-sub`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:614
+assert_return(
+  () => invoke($1, `mul-add`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x0, 0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:618
+assert_return(
+  () => invoke($1, `mul-sub`, [
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+  ]),
+  [i16x8([0x0, 0x1, 0x4, 0x9, 0x10, 0x19, 0x24, 0x31])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:622
+assert_return(
+  () => invoke($1, `sub-add`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:626
+assert_return(
+  () => invoke($1, `add-neg`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:629
+assert_return(
+  () => invoke($1, `mul-neg`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x0, 0xfffe, 0xfffc, 0xfffa, 0xfff8, 0xfff6, 0xfff4, 0xfff2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith.wast:632
+assert_return(
+  () => invoke($1, `sub-neg`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+  ]),
+  [i16x8([0x0, 0xfffe, 0xfffc, 0xfffa, 0xfff8, 0xfff6, 0xfff4, 0xfff2])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js
new file mode 100644
index 0000000000..759c59683b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_arith2.wast.js
@@ -0,0 +1,1558 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_arith2.wast
+
+// ./test/core/simd/simd_i16x8_arith2.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:33
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:36
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:39
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:42
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:45
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:48
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:51
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:54
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:57
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:60
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:63
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:66
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:69
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:72
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:75
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:78
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:81
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:84
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:87
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:90
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:93
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:96
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:99
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:102
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:105
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:108
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:111
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:114
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:117
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:120
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:123
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:126
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:129
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:132
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:135
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:138
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:141
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:144
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:147
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:150
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:153
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:156
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:159
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:162
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:165
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:168
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:171
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x8000, 0x8000, 0x8000, 0x8000, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:174
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:177
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:180
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:183
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x8040, 0x8040, 0x8040, 0x8040, 0x8040, 0x8040, 0x8040, 0x8040])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:186
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:189
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:192
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:195
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:198
+assert_return(
+  () => invoke($0, `i16x8.abs`, [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:200
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:202
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:204
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:206
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:208
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:210
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:212
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:214
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:216
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0xff85, 0xff85, 0xff85, 0xff85, 0xff85, 0xff85, 0xff85, 0xff85]),
+  ]),
+  [i16x8([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:218
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:220
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:222
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:224
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:228
+assert_return(
+  () => invoke($0, `i16x8.min_s_with_const_0`, []),
+  [i16x8([0x8000, 0x8000, 0x4000, 0x4000, 0x4000, 0x4000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:229
+assert_return(
+  () => invoke($0, `i16x8.min_s_with_const_1`, []),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:230
+assert_return(
+  () => invoke($0, `i16x8.min_u_with_const_2`, []),
+  [i16x8([0x8000, 0x8000, 0x4000, 0x4000, 0x4000, 0x4000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:231
+assert_return(
+  () => invoke($0, `i16x8.min_u_with_const_3`, []),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:232
+assert_return(
+  () => invoke($0, `i16x8.max_s_with_const_4`, []),
+  [i16x8([0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:233
+assert_return(
+  () => invoke($0, `i16x8.max_s_with_const_5`, []),
+  [i16x8([0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:234
+assert_return(
+  () => invoke($0, `i16x8.max_u_with_const_6`, []),
+  [i16x8([0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:235
+assert_return(
+  () => invoke($0, `i16x8.max_u_with_const_7`, []),
+  [i16x8([0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:236
+assert_return(
+  () => invoke($0, `i16x8.avgr_u_with_const_8`, []),
+  [i16x8([0xc000, 0xc000, 0x6000, 0x6000, 0x6000, 0x6000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:237
+assert_return(
+  () => invoke($0, `i16x8.avgr_u_with_const_9`, []),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:238
+assert_return(
+  () => invoke($0, `i16x8.abs_with_const_10`, []),
+  [i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:241
+assert_return(
+  () => invoke($0, `i16x8.min_s_with_const_11`, [
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x4000, 0x4000, 0x4000, 0x4000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:243
+assert_return(
+  () => invoke($0, `i16x8.min_s_with_const_12`, [
+    i16x8([0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:245
+assert_return(
+  () => invoke($0, `i16x8.min_u_with_const_13`, [
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x4000, 0x4000, 0x4000, 0x4000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:247
+assert_return(
+  () => invoke($0, `i16x8.min_u_with_const_14`, [
+    i16x8([0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:249
+assert_return(
+  () => invoke($0, `i16x8.max_s_with_const_15`, [
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:251
+assert_return(
+  () => invoke($0, `i16x8.max_s_with_const_16`, [
+    i16x8([0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0]),
+  ]),
+  [i16x8([0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:253
+assert_return(
+  () => invoke($0, `i16x8.max_u_with_const_17`, [
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:255
+assert_return(
+  () => invoke($0, `i16x8.max_u_with_const_18`, [
+    i16x8([0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0]),
+  ]),
+  [i16x8([0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:257
+assert_return(
+  () => invoke($0, `i16x8.avgr_u_with_const_19`, [
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xc000, 0xc000, 0x6000, 0x6000, 0x6000, 0x6000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:259
+assert_return(
+  () => invoke($0, `i16x8.avgr_u_with_const_20`, [
+    i16x8([0x3, 0x3, 0x2, 0x2, 0x1, 0x1, 0x0, 0x0]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:263
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x4000, 0x4000, 0x4000, 0x4000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:266
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x80, 0x80]),
+    i16x8([0x0, 0x0, 0x2, 0x2, 0x1, 0x1, 0x80, 0x80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:269
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x4000, 0x4000, 0x4000, 0x4000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:272
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x80, 0x80]),
+    i16x8([0x0, 0x0, 0x2, 0x2, 0x1, 0x1, 0x80, 0x80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:275
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:278
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x80, 0x80]),
+    i16x8([0x0, 0x0, 0x2, 0x2, 0x1, 0x1, 0x80, 0x80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:281
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:284
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x80, 0x80]),
+    i16x8([0x0, 0x0, 0x2, 0x2, 0x1, 0x1, 0x80, 0x80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:287
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0x4000, 0x4000, 0x7fff, 0x7fff, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xc000, 0xc000, 0x6000, 0x6000, 0x6000, 0x6000, 0xc000, 0xc000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:290
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x80, 0x80]),
+    i16x8([0x0, 0x0, 0x2, 0x2, 0x1, 0x1, 0x80, 0x80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:293
+assert_return(
+  () => invoke($0, `i16x8.abs`, [
+    i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x7fff, 0x7fff, 0x4000, 0x4000, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:297
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:300
+assert_return(
+  () => invoke($0, `i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:303
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:306
+assert_return(
+  () => invoke($0, `i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:309
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:312
+assert_return(
+  () => invoke($0, `i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:315
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:318
+assert_return(
+  () => invoke($0, `i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:321
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:324
+assert_return(
+  () => invoke($0, `i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:327
+assert_return(
+  () => invoke($0, `i16x8.abs`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:329
+assert_return(
+  () => invoke($0, `i16x8.abs`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:331
+assert_return(
+  () => invoke($0, `i16x8.abs`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:333
+assert_return(
+  () => invoke($0, `i16x8.abs`, [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:337
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:338
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:341
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:342
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:343
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:344
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:345
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.avgr_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:346
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.abs (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:350
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:358
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.min_s-arg-empty (result v128)
+      (i16x8.min_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:366
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:374
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.min_u-arg-empty (result v128)
+      (i16x8.min_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:382
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:390
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.max_s-arg-empty (result v128)
+      (i16x8.max_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:398
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:406
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.max_u-arg-empty (result v128)
+      (i16x8.max_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:414
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:422
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.avgr_u-arg-empty (result v128)
+      (i16x8.avgr_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:430
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.abs-arg-empty (result v128)
+      (i16x8.abs)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:440
+let $1 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:479
+assert_return(
+  () => invoke($1, `i16x8.min_s-i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:483
+assert_return(
+  () => invoke($1, `i16x8.min_s-i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:487
+assert_return(
+  () => invoke($1, `i16x8.min_s-i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:491
+assert_return(
+  () => invoke($1, `i16x8.min_s-i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:495
+assert_return(
+  () => invoke($1, `i16x8.min_s-i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:499
+assert_return(
+  () => invoke($1, `i16x8.min_s-i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:502
+assert_return(
+  () => invoke($1, `i16x8.abs-i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:505
+assert_return(
+  () => invoke($1, `i16x8.min_u-i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:509
+assert_return(
+  () => invoke($1, `i16x8.min_u-i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:513
+assert_return(
+  () => invoke($1, `i16x8.min_u-i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:517
+assert_return(
+  () => invoke($1, `i16x8.min_u-i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:521
+assert_return(
+  () => invoke($1, `i16x8.min_u-i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:525
+assert_return(
+  () => invoke($1, `i16x8.min_u-i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:528
+assert_return(
+  () => invoke($1, `i16x8.abs-i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:531
+assert_return(
+  () => invoke($1, `i16x8.max_s-i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:535
+assert_return(
+  () => invoke($1, `i16x8.max_s-i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:539
+assert_return(
+  () => invoke($1, `i16x8.max_s-i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:543
+assert_return(
+  () => invoke($1, `i16x8.max_s-i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:547
+assert_return(
+  () => invoke($1, `i16x8.max_s-i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:551
+assert_return(
+  () => invoke($1, `i16x8.max_s-i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:554
+assert_return(
+  () => invoke($1, `i16x8.abs-i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:557
+assert_return(
+  () => invoke($1, `i16x8.max_u-i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:561
+assert_return(
+  () => invoke($1, `i16x8.max_u-i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:565
+assert_return(
+  () => invoke($1, `i16x8.max_u-i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:569
+assert_return(
+  () => invoke($1, `i16x8.max_u-i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:573
+assert_return(
+  () => invoke($1, `i16x8.max_u-i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:577
+assert_return(
+  () => invoke($1, `i16x8.max_u-i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:580
+assert_return(
+  () => invoke($1, `i16x8.abs-i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:583
+assert_return(
+  () => invoke($1, `i16x8.avgr_u-i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:587
+assert_return(
+  () => invoke($1, `i16x8.avgr_u-i16x8.max_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:591
+assert_return(
+  () => invoke($1, `i16x8.avgr_u-i16x8.max_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:595
+assert_return(
+  () => invoke($1, `i16x8.avgr_u-i16x8.min_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:599
+assert_return(
+  () => invoke($1, `i16x8.avgr_u-i16x8.min_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:603
+assert_return(
+  () => invoke($1, `i16x8.avgr_u-i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:606
+assert_return(
+  () => invoke($1, `i16x8.abs-i16x8.avgr_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_arith2.wast:609
+assert_return(
+  () => invoke($1, `i16x8.abs-i16x8.abs`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js
new file mode 100644
index 0000000000..f0fdcc0868
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_cmp.wast.js
@@ -0,0 +1,4369 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_cmp.wast
+
+// ./test/core/simd/simd_i16x8_cmp.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:23
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:26
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:29
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:32
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:35
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:38
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:41
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:46
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:49
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:52
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:55
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:58
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:63
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:66
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:69
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:72
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:75
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:78
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:81
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:86
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:89
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:94
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:97
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:100
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:103
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:106
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:111
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:114
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:117
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:120
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:123
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:126
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:129
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:134
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:137
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:140
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:143
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:146
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:149
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+    i32x4([0xffff, 0x0, 0x1, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0x0, 0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:152
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:155
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:158
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:167
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:170
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:173
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:176
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:179
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:182
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:185
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:190
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:193
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:196
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:199
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:202
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:207
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:210
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:213
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:216
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:219
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:222
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:225
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xff, 0x7fff, 0x0, 0x0, 0x1, 0x2, 0xfffe, 0xffff]),
+    i16x8([0xff, 0x7fff, 0x0, 0x0, 0x1, 0x2, 0xfffe, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:230
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:233
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:238
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:241
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:244
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:247
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x8081, 0x8283, 0xfdfe, 0xff00, 0x1, 0x27f, 0x80fd, 0xfeff]),
+    i16x8([0xfeff, 0x80fd, 0x27f, 0x1, 0xff00, 0xfdfe, 0x8283, 0x8081]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:250
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x80, 0x81, 0x82, 0x83, 0x0, 0xff, 0x7ffe, 0x7fff]),
+    i16x8([0x7fff, 0x7ffe, 0xff, 0x0, 0x83, 0x82, 0x81, 0x1c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:255
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:258
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:261
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:264
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:267
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:270
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:273
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:278
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:281
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:284
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:287
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:290
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:293
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0x0, 0xffff, 0x0, 0x0, 0x0, 0xffff, 0x0, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:296
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:299
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:302
+assert_return(
+  () => invoke($0, `ne`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:311
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:314
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:317
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:320
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:323
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:326
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:329
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:332
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:335
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:338
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:341
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:344
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:347
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:350
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:353
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:356
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:359
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:362
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:365
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xff, 0x7fff, 0x0, 0x0, 0x1, 0x2, 0xfffe, 0xffff]),
+    i16x8([0xff, 0x7fff, 0x0, 0x0, 0x1, 0x2, 0xfffe, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:368
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:371
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:376
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:379
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:382
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0x0, 0x0, 0x0, 0x0, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:385
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x8081, 0x8283, 0xfdfe, 0xff00, 0x1, 0x27f, 0x80fd, 0xfeff]),
+    i16x8([0xfeff, 0x80fd, 0x27f, 0x1, 0xff00, 0xfdfe, 0x8283, 0x8081]),
+  ]),
+  [i16x8([0xffff, 0x0, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:388
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x80, 0x81, 0x82, 0x83, 0x0, 0xff, 0x7ffe, 0x7fff]),
+    i16x8([0x7fff, 0x7ffe, 0xff, 0x0, 0x83, 0x82, 0x81, 0x1c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:393
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:396
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:399
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:402
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:405
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:408
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:411
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:416
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:419
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:422
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:425
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:428
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:431
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0x0, 0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:434
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:437
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:440
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:449
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:452
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:455
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:458
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:461
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:464
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:467
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:472
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:475
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:478
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:481
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:484
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:489
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:492
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:495
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:498
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:501
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:504
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:507
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xff, 0x7fff, 0x0, 0x0, 0x1, 0x2, 0xfffe, 0xffff]),
+    i16x8([0xff, 0x7fff, 0x0, 0x0, 0x1, 0x2, 0xfffe, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:512
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:515
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:520
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:523
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:526
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:529
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x8081, 0x8283, 0xfdfe, 0xff00, 0x1, 0x27f, 0x80fd, 0xfeff]),
+    i16x8([0xfeff, 0x80fd, 0x27f, 0x1, 0xff00, 0xfdfe, 0x8283, 0x8081]),
+  ]),
+  [i16x8([0xffff, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:532
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x80, 0x81, 0x82, 0x83, 0x0, 0xff, 0x7ffe, 0x7fff]),
+    i16x8([0x7fff, 0x7ffe, 0xff, 0x0, 0x83, 0x82, 0x81, 0x1c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:537
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:540
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:543
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:546
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:549
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:552
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:555
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:560
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:563
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:566
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:569
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:572
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:575
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0x0, 0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:578
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:581
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:584
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:593
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:596
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:599
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:602
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:605
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:608
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:611
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:616
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:619
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:622
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:625
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:628
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:633
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:636
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:639
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:642
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:645
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:648
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:651
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:656
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:659
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:664
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:667
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:670
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0x0, 0x0, 0x0, 0x0, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:673
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:676
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:681
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:684
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:687
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:690
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:693
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:696
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:699
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:704
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:707
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:710
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:713
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:716
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:719
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:722
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:725
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:728
+assert_return(
+  () => invoke($0, `le_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:737
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:740
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:743
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:746
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:749
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:752
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:755
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:760
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:763
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:766
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:769
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:772
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:777
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:780
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:783
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:786
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:789
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:792
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:795
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:800
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:803
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:808
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:811
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:814
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:817
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:820
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:825
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:828
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:831
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:834
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:837
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:840
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:843
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:848
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:851
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:854
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:857
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:860
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:863
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:866
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:869
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:872
+assert_return(
+  () => invoke($0, `le_u`, [
+    i16x8([0xedcb, 0xedcb, 0xedcb, 0xedcb, 0xedcb, 0xedcb, 0xedcb, 0xedcb]),
+    i16x8([0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:881
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:884
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:887
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:890
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:893
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:896
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:899
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:904
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:907
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:910
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:913
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:916
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:921
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:924
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:927
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:930
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:933
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:936
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:939
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:944
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:947
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:952
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:955
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:958
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:961
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:964
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:969
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:972
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:975
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:978
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:981
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:984
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:987
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:992
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:995
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:998
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1001
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1004
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1007
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+    i32x4([0xffff, 0x0, 0x1, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1010
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1013
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1016
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1025
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1028
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1031
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1034
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1037
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1040
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1043
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1048
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1051
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1054
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1057
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1060
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1065
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1068
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1071
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1074
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1077
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1080
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1083
+assert_return(
+  () => invoke($0, `eq`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1088
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1091
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1096
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1099
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1102
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1105
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1108
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0xffff, 0x0, 0xffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1113
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1116
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1119
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1122
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1125
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1128
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1131
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1136
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1139
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1142
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1145
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1148
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1151
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0xffff, 0x0, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1154
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1157
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1160
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1169
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1172
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1175
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1178
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1181
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1184
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1187
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1192
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1195
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1198
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1201
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1204
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1209
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1212
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1215
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1218
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1221
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1224
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1227
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1232
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1235
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1240
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1243
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1246
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1249
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1252
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1257
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1260
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1263
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1266
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1269
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1272
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1275
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1280
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1283
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1286
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1289
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1292
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1295
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+    i32x4([0xffff, 0x0, 0x1, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1298
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1301
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1304
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1313
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1316
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1319
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1322
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1325
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1328
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1331
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+    i16x8([0x100, 0x302, 0x904, 0x1110, 0xa12, 0x1a0b, 0xaa1b, 0xffab]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1336
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1339
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1342
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1345
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1348
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1353
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1356
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1359
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1362
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1365
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1368
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1371
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+    i16x8([0x8000, 0xfffe, 0xffff, 0x0, 0x0, 0x1, 0x2, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1376
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0xc300, 0x0, 0xc2fe, 0x0, 0xbf80, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1379
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x3f80, 0x0, 0x42fe, 0x0, 0x4300, 0x0, 0x437f]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1384
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f, 0xf0f]),
+    i16x8([0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0, 0xf0f0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1387
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1390
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x1, 0x203, 0x409, 0x1011, 0x120a, 0xb1a, 0x1baa, 0xabff]),
+    i16x8([0xffab, 0xaa1b, 0x1a0b, 0xa12, 0x1110, 0x904, 0x302, 0x100]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1393
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8000, 0x8001, 0x8002, 0x8003, 0x8004, 0x8005, 0x8006, 0x8007]),
+    i16x8([0x8007, 0x8006, 0x8005, 0x8004, 0x8003, 0x8002, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1396
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8000, 0x8001, 0xfffe, 0xffff, 0x0, 0xffff, 0x8001, 0x8000]),
+    i16x8([0x8000, 0x8001, 0xffff, 0x0, 0xffff, 0xfffe, 0x8001, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0x0, 0xffff, 0x0, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1401
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1404
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1407
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1410
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1413
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1416
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1419
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1424
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1427
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1430
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1433
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1436
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1439
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1442
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1445
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1448
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1455
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.eq (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1456
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.ge_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1457
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.ge_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1458
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.gt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1459
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.gt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1460
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.le_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1461
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.le_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1462
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.lt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1463
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.lt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1464
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.ne (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1469
+let $1 = instantiate(`(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))
+          )
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1725
+assert_return(() => invoke($1, `eq-in-block`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1726
+assert_return(() => invoke($1, `ne-in-block`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1727
+assert_return(() => invoke($1, `lt_s-in-block`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1728
+assert_return(() => invoke($1, `le_u-in-block`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1729
+assert_return(() => invoke($1, `gt_u-in-block`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1730
+assert_return(() => invoke($1, `ge_s-in-block`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1731
+assert_return(() => invoke($1, `nested-eq`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1732
+assert_return(() => invoke($1, `nested-ne`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1733
+assert_return(() => invoke($1, `nested-lt_s`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1734
+assert_return(() => invoke($1, `nested-le_u`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1735
+assert_return(() => invoke($1, `nested-gt_u`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1736
+assert_return(() => invoke($1, `nested-ge_s`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1737
+assert_return(() => invoke($1, `as-param`, []), []);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1742
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.eq-1st-arg-empty (result v128)
+      (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1750
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.eq-arg-empty (result v128)
+      (i16x8.eq)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1758
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.ne-1st-arg-empty (result v128)
+      (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1766
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.ne-arg-empty (result v128)
+      (i16x8.ne)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1774
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1782
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.lt_s-arg-empty (result v128)
+      (i16x8.lt_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1790
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1798
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.lt_u-arg-empty (result v128)
+      (i16x8.lt_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1806
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1814
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.le_s-arg-empty (result v128)
+      (i16x8.le_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1822
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1830
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.le_u-arg-empty (result v128)
+      (i16x8.le_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1838
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1846
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.gt_s-arg-empty (result v128)
+      (i16x8.gt_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1854
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1862
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.gt_u-arg-empty (result v128)
+      (i16x8.gt_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1870
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1878
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.ge_s-arg-empty (result v128)
+      (i16x8.ge_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1886
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_cmp.wast:1894
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.ge_u-arg-empty (result v128)
+      (i16x8.ge_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js
new file mode 100644
index 0000000000..5a594d4ce4
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extadd_pairwise_i8x16.wast.js
@@ -0,0 +1,184 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:11
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:13
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:15
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:17
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [i16x8([0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:19
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0xff02, 0xff02, 0xff02, 0xff02, 0xff02, 0xff02, 0xff02, 0xff02])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:21
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff00, 0xff00, 0xff00, 0xff00, 0xff00, 0xff00, 0xff00, 0xff00])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:23
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:25
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:29
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:31
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:33
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:35
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [i16x8([0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:37
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:39
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:41
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:43
+assert_return(
+  () => invoke($0, `i16x8.extadd_pairwise_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe, 0x1fe])],
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:47
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extadd_pairwise_i8x16_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:48
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extadd_pairwise_i8x16_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:52
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extadd_pairwise_i8x16_s-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extadd_pairwise_i8x16.wast:60
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extadd_pairwise_i8x16_u-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js
new file mode 100644
index 0000000000..4e102de588
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_extmul_i8x16.wast.js
@@ -0,0 +1,1066 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:13
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:16
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:19
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:22
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:25
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:28
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:31
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:34
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:37
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:40
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:43
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x1040, 0x1040, 0x1040, 0x1040, 0x1040, 0x1040, 0x1040, 0x1040])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:46
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:49
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:52
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:55
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:58
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:61
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:64
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:67
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:70
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:73
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:76
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:79
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:82
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:85
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:88
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:93
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:96
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:99
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:102
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:105
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:108
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:111
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:114
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:117
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:120
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:123
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x1040, 0x1040, 0x1040, 0x1040, 0x1040, 0x1040, 0x1040, 0x1040])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:126
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:129
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:132
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:135
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:138
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:141
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:144
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:147
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:150
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:153
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:156
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:159
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:162
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:165
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:168
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:173
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:176
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:179
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:182
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:185
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:188
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:191
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:194
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:197
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:200
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x9000, 0x9000, 0x9000, 0x9000, 0x9000, 0x9000, 0x9000, 0x9000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:203
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:206
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:209
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:212
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:215
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x817e, 0x817e, 0x817e, 0x817e, 0x817e, 0x817e, 0x817e, 0x817e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:218
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x807f, 0x807f, 0x807f, 0x807f, 0x807f, 0x807f, 0x807f, 0x807f])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:221
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:224
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:227
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:230
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x4080, 0x4080, 0x4080, 0x4080, 0x4080, 0x4080, 0x4080, 0x4080])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:233
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:236
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:239
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:242
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:245
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:248
+assert_return(
+  () => invoke($0, `i16x8.extmul_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:253
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:256
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:259
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:262
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:265
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:268
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:271
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0, 0xfc0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:274
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [i16x8([0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:277
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0, 0x90c0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:280
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x9000, 0x9000, 0x9000, 0x9000, 0x9000, 0x9000, 0x9000, 0x9000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:283
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [i16x8([0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40, 0x8f40])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:286
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:289
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:292
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:295
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x817e, 0x817e, 0x817e, 0x817e, 0x817e, 0x817e, 0x817e, 0x817e])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:298
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x807f, 0x807f, 0x807f, 0x807f, 0x807f, 0x807f, 0x807f, 0x807f])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:301
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:304
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01, 0x3f01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:307
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:310
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x4080, 0x4080, 0x4080, 0x4080, 0x4080, 0x4080, 0x4080, 0x4080])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:313
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:316
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:319
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:322
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81, 0x7e81])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:325
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80, 0x7f80])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:328
+assert_return(
+  () => invoke($0, `i16x8.extmul_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01, 0xfe01])],
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:333
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extmul_low_i8x16_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:334
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extmul_high_i8x16_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:335
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extmul_low_i8x16_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:336
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extmul_high_i8x16_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:340
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:348
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extmul_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:356
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:364
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extmul_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:372
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:380
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extmul_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:388
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_extmul_i8x16.wast:396
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extmul_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js
new file mode 100644
index 0000000000..7d02f8a85f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_q15mulr_sat_s.wast.js
@@ -0,0 +1,283 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:4
+let $0 = instantiate(`(module
+  (func (export "i16x8.q15mulr_sat_s") (param v128 v128) (result v128) (i16x8.q15mulr_sat_s (local.get 0) (local.get 1)))
+)`);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:10
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:13
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:16
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:19
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:22
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:25
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:28
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:31
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:34
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:37
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000, 0x2000])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:40
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x2001, 0x2001, 0x2001, 0x2001, 0x2001, 0x2001, 0x2001, 0x2001])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:43
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:46
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:49
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:52
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:55
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:58
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:61
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:64
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:67
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:70
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:73
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:76
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:79
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:82
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:85
+assert_return(
+  () => invoke($0, `i16x8.q15mulr_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:90
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.q15mulr_sat_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:94
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_q15mulr_sat_s.wast:102
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.q15mulr_sat_s-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js
new file mode 100644
index 0000000000..999c6a2b31
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i16x8_sat_arith.wast.js
@@ -0,0 +1,2150 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:13
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:16
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:19
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:22
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:25
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:28
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:31
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:34
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:37
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:40
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:43
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:46
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:49
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:52
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:55
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:58
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:61
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:64
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:67
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:70
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:73
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:76
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:79
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:82
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:85
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:88
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:91
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:94
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:97
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:100
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:103
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:106
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:109
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:112
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:115
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:118
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:121
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:124
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:127
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:130
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x1, 0x7f81, 0x1, 0x7f81, 0x1, 0x7f81, 0x1, 0x7f81])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:133
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x1, 0xff81, 0x1, 0xff81, 0x1, 0xff81, 0x1, 0xff81])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:136
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:139
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i16x8([0x1, 0xffc1, 0x1, 0xffc1, 0x1, 0xffc1, 0x1, 0xffc1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:142
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:145
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:148
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0x7d7b, 0x7d7b, 0x7d7b, 0x7d7b, 0x7d7b, 0x7d7b, 0x7d7b, 0x7d7b]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:151
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [i16x8([0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:154
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678]),
+  ]),
+  [i16x8([0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:157
+assert_return(
+  () => invoke($0, `i16x8.add_sat_s`, [
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+    i16x8([0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:162
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:165
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:168
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:171
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:174
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:177
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:180
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:183
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:186
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:189
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:192
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:195
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:198
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:201
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:204
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:207
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:210
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:213
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:216
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:219
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:222
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:225
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:228
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:231
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:234
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:237
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:240
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:243
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:246
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:249
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:252
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:255
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:258
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:261
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:264
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:267
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:270
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:273
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:276
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x8000, 0xffff, 0x8000, 0xffff, 0x8000, 0xffff, 0x8000, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:279
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x1, 0x7f81, 0x1, 0x7f81, 0x1, 0x7f81, 0x1, 0x7f81])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:282
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x1, 0xff81, 0x1, 0xff81, 0x1, 0xff81, 0x1, 0xff81])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:285
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:288
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1, 0x1, 0x7fc1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:291
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:294
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:297
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:300
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:303
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678]),
+  ]),
+  [i16x8([0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac, 0x68ac])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:306
+assert_return(
+  () => invoke($0, `i16x8.add_sat_u`, [
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+    i16x8([0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:311
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:314
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:317
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:320
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:323
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:326
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:329
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:332
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:335
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:338
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:341
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:344
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:347
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:350
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:353
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8003, 0x8003, 0x8003, 0x8003, 0x8003, 0x8003, 0x8003, 0x8003])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:356
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:359
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:362
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:365
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:368
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:371
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:374
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:377
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:380
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:383
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:386
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:389
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:392
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:395
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:398
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:401
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:404
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:407
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:410
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:413
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:416
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:419
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:422
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:425
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:428
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x1, 0x8081, 0x1, 0x8081, 0x1, 0x8081, 0x1, 0x8081])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:431
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x1, 0x81, 0x1, 0x81, 0x1, 0x81, 0x1, 0x81])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:434
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x8041, 0x1, 0x8041, 0x1, 0x8041, 0x1, 0x8041])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:437
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i16x8([0x1, 0x41, 0x1, 0x41, 0x1, 0x41, 0x1, 0x41])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:440
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:443
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:446
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [i16x8([0x5264, 0x5264, 0x5264, 0x5264, 0x5264, 0x5264, 0x5264, 0x5264])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:449
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7]),
+  ]),
+  [i16x8([0x6072, 0x6072, 0x6072, 0x6072, 0x6072, 0x6072, 0x6072, 0x6072])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:452
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678, 0x5678]),
+  ]),
+  [i16x8([0xbbbc, 0xbbbc, 0xbbbc, 0xbbbc, 0xbbbc, 0xbbbc, 0xbbbc, 0xbbbc])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:455
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_s`, [
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+    i16x8([0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc, 0xedcc]),
+  ]),
+  [i16x8([0xa2df, 0xa2df, 0xa2df, 0xa2df, 0xa2df, 0xa2df, 0xa2df, 0xa2df])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:460
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:463
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:466
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:469
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:472
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:475
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:478
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:481
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:484
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:487
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:490
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:493
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc, 0x7ffc])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:496
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:499
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:502
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:505
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:508
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:511
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:514
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:517
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:520
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:523
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:526
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:529
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:532
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:535
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:538
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:541
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:544
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:547
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:550
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:553
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:556
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:559
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:562
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:565
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:568
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:571
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:574
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i16x8([0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:577
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i16x8([0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:580
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i16x8([0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:583
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i16x8([0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:586
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i16x8([0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:589
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0xffff, 0xfffe, 0xfffd, 0xfffc, 0xfffb, 0xfffa, 0xfff9]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:592
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]),
+    i16x8([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:595
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039]),
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:598
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5, 0xddd5]),
+    i16x8([0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7, 0xcfc7]),
+  ]),
+  [i16x8([0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e, 0xe0e])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:601
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234]),
+    i16x8([0xa988, 0xa988, 0xa988, 0xa988, 0xa988, 0xa988, 0xa988, 0xa988]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:604
+assert_return(
+  () => invoke($0, `i16x8.sub_sat_u`, [
+    i16x8([0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef, 0xcdef]),
+    i16x8([0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab, 0x90ab]),
+  ]),
+  [i16x8([0x3d44, 0x3d44, 0x3d44, 0x3d44, 0x3d44, 0x3d44, 0x3d44, 0x3d44])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:609
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:612
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:615
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:618
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:623
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.add_sat_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:624
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.add_sat_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:625
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.sub_sat_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:626
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.sub_sat_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:630
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:638
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.add_sat_s-arg-empty (result v128)
+      (i16x8.add_sat_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:646
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:654
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.add_sat_u-arg-empty (result v128)
+      (i16x8.add_sat_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:662
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:670
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.sub_sat_s-arg-empty (result v128)
+      (i16x8.sub_sat_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:678
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:686
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.sub_sat_u-arg-empty (result v128)
+      (i16x8.sub_sat_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:696
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:715
+assert_return(
+  () => invoke($1, `sat-add_s-sub_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:719
+assert_return(
+  () => invoke($1, `sat-add_s-sub_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:723
+assert_return(
+  () => invoke($1, `sat-add_u-sub_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:727
+assert_return(
+  () => invoke($1, `sat-add_u-sub_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:731
+assert_return(
+  () => invoke($1, `sat-add_s-neg`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:734
+assert_return(
+  () => invoke($1, `sat-add_u-neg`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:737
+assert_return(
+  () => invoke($1, `sat-sub_s-neg`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i16x8_sat_arith.wast:740
+assert_return(
+  () => invoke($1, `sat-sub_u-neg`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js
new file mode 100644
index 0000000000..42976320d0
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith.wast.js
@@ -0,0 +1,1801 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_arith.wast
+
+// ./test/core/simd/simd_i32x4_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_arith.wast:13
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:16
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:19
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:22
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:25
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:28
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:31
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:34
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:37
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:40
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:43
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:46
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:49
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:52
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:55
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:58
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:61
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:64
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:67
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:70
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:73
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:76
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:79
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:82
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:85
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:88
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:91
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:94
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:97
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:100
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:103
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:106
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:109
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:112
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:115
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:118
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:121
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:124
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:127
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i8x16([0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:130
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:133
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i16x8([0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:136
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:139
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:142
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:145
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0xbf800000, 0xbf800000, 0xbf800000, 0xbf800000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:148
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:151
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x7f800001, 0x7f800001, 0x7f800001, 0x7f800001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:154
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xff800001, 0xff800001, 0xff800001, 0xff800001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:157
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x7fc00001, 0x7fc00001, 0x7fc00001, 0x7fc00001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:160
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0xffffffff, 0xfffffffe, 0xfffffffd]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:163
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+  ]),
+  [i32x4([0x0, 0x3, 0x6, 0x9])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:166
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i32x4([0x932c05a4, 0x932c05a4, 0x932c05a4, 0x932c05a4])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:169
+assert_return(
+  () => invoke($0, `i32x4.add`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0xa2e02467, 0xa2e02467, 0xa2e02467, 0xa2e02467])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:174
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:177
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:180
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:183
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:186
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:189
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:192
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:195
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:198
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:201
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:204
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:207
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffffffc, 0x7ffffffc, 0x7ffffffc, 0x7ffffffc])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:210
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:213
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:216
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000003, 0x80000003, 0x80000003, 0x80000003])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:219
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:222
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:225
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:228
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:231
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:234
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:237
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:240
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:243
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:246
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:249
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:252
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:255
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:258
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:261
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:264
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:267
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:270
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:273
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:276
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:279
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:282
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:285
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:288
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i8x16([0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:291
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:294
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i16x8([0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000, 0x0, 0x8000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:297
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:300
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:303
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:306
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x40800000, 0x40800000, 0x40800000, 0x40800000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:309
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0xc0800000, 0xc0800000, 0xc0800000, 0xc0800000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:312
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x80800001, 0x80800001, 0x80800001, 0x80800001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:315
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x800001, 0x800001, 0x800001, 0x800001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:318
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x80400001, 0x80400001, 0x80400001, 0x80400001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:321
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0xffffffff, 0xfffffffe, 0xfffffffd]),
+  ]),
+  [i32x4([0x0, 0x2, 0x4, 0x6])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:324
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xfffffffe, 0xfffffffd])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:327
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0xbf9a69d2, 0xbf9a69d2, 0xbf9a69d2, 0xbf9a69d2]),
+    i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2]),
+  ]),
+  [i32x4([0x76046700, 0x76046700, 0x76046700, 0x76046700])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:330
+assert_return(
+  () => invoke($0, `i32x4.sub`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0x7e777777, 0x7e777777, 0x7e777777, 0x7e777777])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:335
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:338
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:341
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:344
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:347
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:350
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:353
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:356
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:359
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:362
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:365
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:368
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:371
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:374
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:377
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:380
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:383
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:386
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:389
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:392
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:395
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:398
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:401
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:404
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:407
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:410
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:413
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:416
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:419
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:422
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:425
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+  ]),
+  [i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:428
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:431
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:434
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:437
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:440
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:443
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:446
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:449
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000]),
+    i8x16([0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:452
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:455
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i16x8([0x0, 0x2, 0x0, 0x2, 0x0, 0x2, 0x0, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:458
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:461
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:464
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:467
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:470
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x8000, 0x8000, 0x8000, 0x8000]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:473
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:476
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0xff800000, 0xff800000, 0xff800000, 0xff800000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:479
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x7fc00000, 0x7fc00000, 0x7fc00000, 0x7fc00000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:482
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0xffffffff, 0xfffffffe, 0xfffffffd]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xfffffffc, 0xfffffff7])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:485
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+  ]),
+  [i32x4([0x0, 0x2, 0x8, 0x12])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:488
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x3ade68b1, 0x3ade68b1, 0x3ade68b1, 0x3ade68b1]),
+  ]),
+  [i32x4([0xfbff5385, 0xfbff5385, 0xfbff5385, 0xfbff5385])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:491
+assert_return(
+  () => invoke($0, `i32x4.mul`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0x2a42d208, 0x2a42d208, 0x2a42d208, 0x2a42d208])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:496
+assert_return(
+  () => invoke($0, `i32x4.neg`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:498
+assert_return(
+  () => invoke($0, `i32x4.neg`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:500
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:502
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+  ]),
+  [i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:504
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:506
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:508
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:510
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:512
+assert_return(
+  () => invoke($0, `i32x4.neg`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:514
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:516
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:518
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:520
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:522
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:524
+assert_return(
+  () => invoke($0, `i32x4.neg`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:528
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.neg (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:529
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.add (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:530
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:531
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:535
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.neg-arg-empty (result v128)
+      (i32x4.neg)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:543
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.add-1st-arg-empty (result v128)
+      (i32x4.add (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:551
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.add-arg-empty (result v128)
+      (i32x4.add)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:559
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.sub-1st-arg-empty (result v128)
+      (i32x4.sub (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:567
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.sub-arg-empty (result v128)
+      (i32x4.sub)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:575
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.mul-1st-arg-empty (result v128)
+      (i32x4.mul (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:583
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.mul-arg-empty (result v128)
+      (i32x4.mul)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:593
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_arith.wast:610
+assert_return(
+  () => invoke($1, `add-sub`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+  ]),
+  [i32x4([0x0, 0x1, 0x2, 0x3])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:614
+assert_return(
+  () => invoke($1, `mul-add`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x4, 0x8, 0xc])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:618
+assert_return(
+  () => invoke($1, `mul-sub`, [
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+  ]),
+  [i32x4([0x0, 0x1, 0x4, 0x9])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:622
+assert_return(
+  () => invoke($1, `sub-add`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+    i32x4([0x0, 0x2, 0x4, 0x6]),
+  ]),
+  [i32x4([0x0, 0x1, 0x2, 0x3])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:626
+assert_return(
+  () => invoke($1, `add-neg`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:629
+assert_return(
+  () => invoke($1, `mul-neg`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0xfffffffe, 0xfffffffc, 0xfffffffa])],
+);
+
+// ./test/core/simd/simd_i32x4_arith.wast:632
+assert_return(
+  () => invoke($1, `sub-neg`, [
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+    i32x4([0x0, 0x1, 0x2, 0x3]),
+  ]),
+  [i32x4([0x0, 0xfffffffe, 0xfffffffc, 0xfffffffa])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js
new file mode 100644
index 0000000000..42d50dfefd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_arith2.wast.js
@@ -0,0 +1,1279 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_arith2.wast
+
+// ./test/core/simd/simd_i32x4_arith2.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:28
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:31
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:34
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:37
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:40
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:43
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:46
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:49
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:52
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:55
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i32x4([0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:58
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:61
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:64
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:67
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:70
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:73
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:76
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:79
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:82
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:85
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:88
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i32x4([0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:91
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:94
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:97
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:100
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:103
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:106
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:109
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:112
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:115
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:118
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:121
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i32x4([0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:124
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:127
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:130
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:133
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:136
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:139
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:142
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:145
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:148
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:151
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:154
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+    i32x4([0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [i32x4([0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:157
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+    i32x4([0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:160
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x1, 0x1, 0x1, 0x1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:162
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:164
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:166
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:168
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:170
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:172
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:174
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:176
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x7b, 0x7b, 0x7b, 0x7b])]),
+  [i32x4([0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:178
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0xffffff85, 0xffffff85, 0xffffff85, 0xffffff85]),
+  ]),
+  [i32x4([0x7b, 0x7b, 0x7b, 0x7b])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:180
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x80, 0x80, 0x80, 0x80])]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:182
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0xffffff80, 0xffffff80, 0xffffff80, 0xffffff80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:184
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x80, 0x80, 0x80, 0x80])]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:186
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0xffffff80, 0xffffff80, 0xffffff80, 0xffffff80]),
+  ]),
+  [i32x4([0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:190
+assert_return(
+  () => invoke($0, `i32x4.min_s_with_const_0`, []),
+  [i32x4([0x80000000, 0x40000000, 0x40000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:191
+assert_return(() => invoke($0, `i32x4.min_s_with_const_1`, []), [i32x4([0x0, 0x1, 0x1, 0x0])]);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:192
+assert_return(
+  () => invoke($0, `i32x4.min_u_with_const_2`, []),
+  [i32x4([0x80000000, 0x40000000, 0x40000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:193
+assert_return(() => invoke($0, `i32x4.min_u_with_const_3`, []), [i32x4([0x0, 0x1, 0x1, 0x0])]);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:194
+assert_return(
+  () => invoke($0, `i32x4.max_s_with_const_4`, []),
+  [i32x4([0xffffffff, 0x7fffffff, 0x7fffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:195
+assert_return(() => invoke($0, `i32x4.max_s_with_const_5`, []), [i32x4([0x3, 0x2, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:196
+assert_return(
+  () => invoke($0, `i32x4.max_u_with_const_6`, []),
+  [i32x4([0xffffffff, 0x7fffffff, 0x7fffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:197
+assert_return(() => invoke($0, `i32x4.max_u_with_const_7`, []), [i32x4([0x3, 0x2, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:198
+assert_return(
+  () => invoke($0, `i32x4.abs_with_const_8`, []),
+  [i32x4([0x80000000, 0x7fffffff, 0x40000000, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:201
+assert_return(
+  () => invoke($0, `i32x4.min_s_with_const_9`, [
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x40000000, 0x40000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:203
+assert_return(
+  () => invoke($0, `i32x4.min_s_with_const_10`, [i32x4([0x3, 0x2, 0x1, 0x0])]),
+  [i32x4([0x0, 0x1, 0x1, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:205
+assert_return(
+  () => invoke($0, `i32x4.min_u_with_const_11`, [
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x40000000, 0x40000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:207
+assert_return(
+  () => invoke($0, `i32x4.min_u_with_const_12`, [i32x4([0x3, 0x2, 0x1, 0x0])]),
+  [i32x4([0x0, 0x1, 0x1, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:209
+assert_return(
+  () => invoke($0, `i32x4.max_s_with_const_13`, [
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0xffffffff, 0x7fffffff, 0x7fffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:211
+assert_return(
+  () => invoke($0, `i32x4.max_s_with_const_14`, [i32x4([0x3, 0x2, 0x1, 0x0])]),
+  [i32x4([0x3, 0x2, 0x2, 0x3])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:213
+assert_return(
+  () => invoke($0, `i32x4.max_u_with_const_15`, [
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0xffffffff, 0x7fffffff, 0x7fffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:215
+assert_return(
+  () => invoke($0, `i32x4.max_u_with_const_16`, [i32x4([0x3, 0x2, 0x1, 0x0])]),
+  [i32x4([0x3, 0x2, 0x2, 0x3])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:219
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x80000000, 0x7fffffff, 0x40000000, 0xffffffff]),
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x40000000, 0x40000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:222
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x1, 0x2, 0x80]),
+    i32x4([0x0, 0x2, 0x1, 0x80]),
+  ]),
+  [i32x4([0x0, 0x1, 0x1, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:225
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x80000000, 0x7fffffff, 0x40000000, 0xffffffff]),
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0x80000000, 0x40000000, 0x40000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:228
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x1, 0x2, 0x80]),
+    i32x4([0x0, 0x2, 0x1, 0x80]),
+  ]),
+  [i32x4([0x0, 0x1, 0x1, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:231
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x80000000, 0x7fffffff, 0x40000000, 0xffffffff]),
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0xffffffff, 0x7fffffff, 0x7fffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:234
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x1, 0x2, 0x80]),
+    i32x4([0x0, 0x2, 0x1, 0x80]),
+  ]),
+  [i32x4([0x0, 0x2, 0x2, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:237
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x80000000, 0x7fffffff, 0x40000000, 0xffffffff]),
+    i32x4([0xffffffff, 0x40000000, 0x7fffffff, 0x80000000]),
+  ]),
+  [i32x4([0xffffffff, 0x7fffffff, 0x7fffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:240
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x1, 0x2, 0x80]),
+    i32x4([0x0, 0x2, 0x1, 0x80]),
+  ]),
+  [i32x4([0x0, 0x2, 0x2, 0x80])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:243
+assert_return(
+  () => invoke($0, `i32x4.abs`, [
+    i32x4([0x80000000, 0x7fffffff, 0x40000000, 0xffffffff]),
+  ]),
+  [i32x4([0x80000000, 0x7fffffff, 0x40000000, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:247
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:250
+assert_return(
+  () => invoke($0, `i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:253
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:256
+assert_return(
+  () => invoke($0, `i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:259
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:262
+assert_return(
+  () => invoke($0, `i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:265
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:268
+assert_return(
+  () => invoke($0, `i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:271
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:273
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:275
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:277
+assert_return(
+  () => invoke($0, `i32x4.abs`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:281
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:282
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:283
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:284
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:285
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:286
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:287
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:288
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:289
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:290
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:291
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:292
+assert_malformed(
+  () => instantiate(`(memory 1) (func (result v128) (f64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:295
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:296
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:297
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:298
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:299
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.abs (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:303
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.min_s-1st-arg-empty (result v128)
+      (i32x4.min_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:311
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.min_s-arg-empty (result v128)
+      (i32x4.min_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:319
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.min_u-1st-arg-empty (result v128)
+      (i32x4.min_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:327
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.min_u-arg-empty (result v128)
+      (i32x4.min_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:335
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.max_s-1st-arg-empty (result v128)
+      (i32x4.max_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:343
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.max_s-arg-empty (result v128)
+      (i32x4.max_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:351
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.max_u-1st-arg-empty (result v128)
+      (i32x4.max_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:359
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.max_u-arg-empty (result v128)
+      (i32x4.max_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:367
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.abs-arg-empty (result v128)
+      (i32x4.abs)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:377
+let $1 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:405
+assert_return(
+  () => invoke($1, `i32x4.min_s-i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:409
+assert_return(
+  () => invoke($1, `i32x4.min_s-i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:413
+assert_return(
+  () => invoke($1, `i32x4.min_s-i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:417
+assert_return(
+  () => invoke($1, `i32x4.min_s-i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:421
+assert_return(
+  () => invoke($1, `i32x4.min_s-i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:424
+assert_return(
+  () => invoke($1, `i32x4.abs-i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:427
+assert_return(
+  () => invoke($1, `i32x4.min_u-i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:431
+assert_return(
+  () => invoke($1, `i32x4.min_u-i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:435
+assert_return(
+  () => invoke($1, `i32x4.min_u-i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:439
+assert_return(
+  () => invoke($1, `i32x4.min_u-i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:443
+assert_return(
+  () => invoke($1, `i32x4.min_u-i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:446
+assert_return(
+  () => invoke($1, `i32x4.abs-i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:449
+assert_return(
+  () => invoke($1, `i32x4.max_s-i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:453
+assert_return(
+  () => invoke($1, `i32x4.max_s-i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:457
+assert_return(
+  () => invoke($1, `i32x4.max_s-i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:461
+assert_return(
+  () => invoke($1, `i32x4.max_s-i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:465
+assert_return(
+  () => invoke($1, `i32x4.max_s-i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:468
+assert_return(
+  () => invoke($1, `i32x4.abs-i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:471
+assert_return(
+  () => invoke($1, `i32x4.max_u-i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:475
+assert_return(
+  () => invoke($1, `i32x4.max_u-i32x4.max_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:479
+assert_return(
+  () => invoke($1, `i32x4.max_u-i32x4.min_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:483
+assert_return(
+  () => invoke($1, `i32x4.max_u-i32x4.min_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:487
+assert_return(
+  () => invoke($1, `i32x4.max_u-i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:490
+assert_return(
+  () => invoke($1, `i32x4.abs-i32x4.max_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_arith2.wast:493
+assert_return(
+  () => invoke($1, `i32x4.abs-i32x4.abs`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js
new file mode 100644
index 0000000000..7e3efca7a3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_cmp.wast.js
@@ -0,0 +1,4369 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_cmp.wast
+
+// ./test/core/simd/simd_i32x4_cmp.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:23
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:26
+assert_return(
+  () => invoke($0, `eq`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:29
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:32
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:35
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:38
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:41
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:46
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:49
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:52
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:55
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:58
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:63
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:66
+assert_return(
+  () => invoke($0, `eq`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:69
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:72
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:75
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:78
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:81
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:86
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:89
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:94
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:97
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:100
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:103
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:106
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:111
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:114
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:117
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:120
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:123
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:126
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:129
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:134
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:137
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:140
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:143
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:146
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:149
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0xffffffff, 0x0, 0x1, 0xffff]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x0, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:152
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:155
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:158
+assert_return(
+  () => invoke($0, `eq`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:167
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:170
+assert_return(
+  () => invoke($0, `ne`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:173
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:176
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:179
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:182
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:185
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:190
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:193
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:196
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:199
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:202
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:207
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:210
+assert_return(
+  () => invoke($0, `ne`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:213
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:216
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:219
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:222
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:225
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:230
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:233
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:238
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:241
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:244
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:247
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:250
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:255
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:258
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:261
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:264
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:267
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:270
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:273
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:278
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:281
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:284
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:287
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:290
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:293
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:296
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:299
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:302
+assert_return(
+  () => invoke($0, `ne`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:311
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:314
+assert_return(
+  () => invoke($0, `lt_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:317
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:320
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:323
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:326
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:329
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:334
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:337
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:340
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:343
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:346
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:351
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:354
+assert_return(
+  () => invoke($0, `lt_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:357
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:360
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:363
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:366
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:369
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:374
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:377
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:382
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:385
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:388
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:391
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:394
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:399
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:402
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:405
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:408
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:411
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:414
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:417
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:422
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:425
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:428
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:431
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:434
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:437
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:440
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:443
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:446
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x90abcdf0, 0x90abcdf0, 0x90abcdf0, 0x90abcdf0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:455
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:458
+assert_return(
+  () => invoke($0, `lt_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:461
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:464
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:467
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:470
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:473
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:478
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:481
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:484
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:487
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:490
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:495
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:498
+assert_return(
+  () => invoke($0, `lt_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:501
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:504
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:507
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:510
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:513
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:518
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:521
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:526
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:529
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:532
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:535
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:538
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:543
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:546
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:549
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:552
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:555
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:558
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:561
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:566
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:569
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:572
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:575
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:578
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:581
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:584
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:587
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:590
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x90abcdf0, 0x90abcdf0, 0x90abcdf0, 0x90abcdf0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:599
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:602
+assert_return(
+  () => invoke($0, `le_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:605
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:608
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:611
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:614
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:617
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:622
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:625
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:628
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:631
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:634
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:639
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:642
+assert_return(
+  () => invoke($0, `le_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:645
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:648
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:651
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:654
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:657
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:662
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:665
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:670
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:673
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:676
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:679
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:682
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:687
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:690
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:693
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:696
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:699
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:702
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:705
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:710
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:713
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:716
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:719
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:722
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:725
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:728
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:731
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:734
+assert_return(
+  () => invoke($0, `le_s`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:743
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:746
+assert_return(
+  () => invoke($0, `le_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:749
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:752
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:755
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:758
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:761
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:766
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:769
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:772
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:775
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:778
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:783
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:786
+assert_return(
+  () => invoke($0, `le_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:789
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:792
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:795
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:798
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:801
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:806
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:809
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:814
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:817
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:820
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:823
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:826
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:831
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:834
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:837
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:840
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:843
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:846
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:849
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:854
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:857
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:860
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:863
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:866
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:869
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:872
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:875
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:878
+assert_return(
+  () => invoke($0, `le_u`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:887
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:890
+assert_return(
+  () => invoke($0, `gt_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:893
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:896
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:899
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:902
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:905
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:910
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:913
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:916
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:919
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:922
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:927
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:930
+assert_return(
+  () => invoke($0, `gt_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:933
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:936
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:939
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:942
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:945
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:950
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:953
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:958
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:961
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:964
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:967
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:970
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:975
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:978
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:981
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:984
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:987
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:990
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:993
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:998
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1001
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1004
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1007
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1010
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1013
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xffff, 0x0, 0x1, 0x8000]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1016
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1019
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1022
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+    i32x4([0x90abcdef, 0x90abcdef, 0x90abcdef, 0x90abcdef]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1031
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1034
+assert_return(
+  () => invoke($0, `gt_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1037
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1040
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1043
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1046
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1049
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1054
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1057
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1060
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1063
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1066
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1071
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1074
+assert_return(
+  () => invoke($0, `gt_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1077
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1080
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1083
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1086
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1089
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1094
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1097
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1102
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1105
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1108
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1111
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1114
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1119
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1122
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1125
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1128
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1131
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1134
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1137
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1142
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1145
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1148
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1151
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1154
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1157
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1160
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1163
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1166
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1175
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1178
+assert_return(
+  () => invoke($0, `ge_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1181
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1184
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1187
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1190
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1193
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1198
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1201
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1204
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1207
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1210
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1215
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1218
+assert_return(
+  () => invoke($0, `ge_s`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1221
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1224
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1227
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1230
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1233
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1238
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1241
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1246
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1249
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1252
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1255
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1258
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1263
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1266
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1269
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1272
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1275
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1278
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1281
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x55555555, 0x55555555, 0x55555555, 0x55555555]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1286
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1289
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1292
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1295
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1298
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1301
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xffff, 0x0, 0x1, 0x8000]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1304
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1307
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1310
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1319
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1322
+assert_return(
+  () => invoke($0, `ge_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1325
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1328
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1331
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1334
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1337
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+    i32x4([0x3020100, 0x11100904, 0x1a0b0a12, 0xffabaa1b]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1342
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1345
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1348
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1351
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1354
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1359
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1362
+assert_return(
+  () => invoke($0, `ge_u`, [i32x4([0x0, 0x0, 0x0, 0x0]), i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1365
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1368
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1371
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1374
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1377
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000001, 0xffffffff, 0x0, 0xffffffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1382
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xc3000000, 0xc2fe0000, 0xbf800000, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1385
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x3f800000, 0x42fe0000, 0x43000000, 0x437f0000]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1390
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f]),
+    i32x4([0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0, 0xf0f0f0f0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1393
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1396
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x2030001, 0x10110409, 0xb1a120a, 0xabff1baa]),
+    i32x4([0xaa1bffab, 0xa121a0b, 0x9041110, 0x1000302]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1399
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x80018000, 0x80038002, 0x80058004, 0x80078006]),
+    i32x4([0x80078006, 0x80058004, 0x80038002, 0x80018000]),
+  ]),
+  [i32x4([0x0, 0x0, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1402
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x80000000, 0x7fffffff, 0x0, 0xffffffff]),
+    i32x4([0x80000000, 0x80000001, 0xffffffff, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1407
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1410
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1413
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1416
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1419
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1422
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xff80ff80, 0x0, 0x1, 0xffffffff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1425
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1430
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1433
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1436
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1439
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1442
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1445
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+    i16x8([0xffff, 0xffff, 0x0, 0x0, 0x1, 0x1, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x0, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1448
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+    i16x8([0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1451
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+    i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1454
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+    i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1461
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.eq (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1462
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.ge_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1463
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.ge_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1464
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.gt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1465
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.gt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1466
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.le_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1467
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.le_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1468
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.lt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1469
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.lt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1470
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.ne (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1475
+let $1 = instantiate(`(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))
+          )
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1731
+assert_return(() => invoke($1, `eq-in-block`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1732
+assert_return(() => invoke($1, `ne-in-block`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1733
+assert_return(() => invoke($1, `lt_s-in-block`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1734
+assert_return(() => invoke($1, `le_u-in-block`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1735
+assert_return(() => invoke($1, `gt_u-in-block`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1736
+assert_return(() => invoke($1, `ge_s-in-block`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1737
+assert_return(() => invoke($1, `nested-eq`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1738
+assert_return(() => invoke($1, `nested-ne`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1739
+assert_return(() => invoke($1, `nested-lt_s`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1740
+assert_return(() => invoke($1, `nested-le_u`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1741
+assert_return(() => invoke($1, `nested-gt_u`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1742
+assert_return(() => invoke($1, `nested-ge_s`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1743
+assert_return(() => invoke($1, `as-param`, []), []);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1748
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.eq-1st-arg-empty (result v128)
+      (i32x4.eq (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1756
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.eq-arg-empty (result v128)
+      (i32x4.eq)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1764
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.ne-1st-arg-empty (result v128)
+      (i32x4.ne (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1772
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.ne-arg-empty (result v128)
+      (i32x4.ne)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1780
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.lt_s-1st-arg-empty (result v128)
+      (i32x4.lt_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1788
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.lt_s-arg-empty (result v128)
+      (i32x4.lt_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1796
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.lt_u-1st-arg-empty (result v128)
+      (i32x4.lt_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1804
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.lt_u-arg-empty (result v128)
+      (i32x4.lt_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1812
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.le_s-1st-arg-empty (result v128)
+      (i32x4.le_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1820
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.le_s-arg-empty (result v128)
+      (i32x4.le_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1828
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.le_u-1st-arg-empty (result v128)
+      (i32x4.le_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1836
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.le_u-arg-empty (result v128)
+      (i32x4.le_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1844
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.gt_s-1st-arg-empty (result v128)
+      (i32x4.gt_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1852
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.gt_s-arg-empty (result v128)
+      (i32x4.gt_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1860
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.gt_u-1st-arg-empty (result v128)
+      (i32x4.gt_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1868
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.gt_u-arg-empty (result v128)
+      (i32x4.gt_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1876
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.ge_s-1st-arg-empty (result v128)
+      (i32x4.ge_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1884
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.ge_s-arg-empty (result v128)
+      (i32x4.ge_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1892
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.ge_u-1st-arg-empty (result v128)
+      (i32x4.ge_u (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1900
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.ge_u-arg-empty (result v128)
+      (i32x4.ge_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1910
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.eq (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1911
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.ne (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1912
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.lt_s (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1913
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.lt_u (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1914
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.le_s (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1915
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.le_u (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1916
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.gt_s (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1917
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.gt_u (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1918
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param $$x v128) (param $$y v128) (result v128) (i4x32.ge_s (local.get $$x) (local.get $$y))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i32x4_cmp.wast:1919
+assert_malformed(
+  () => instantiate(`(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/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js
new file mode 100644
index 0000000000..be80d0d2e8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_dot_i16x8.wast.js
@@ -0,0 +1,283 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:4
+let $0 = instantiate(`(module
+  (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128) (i32x4.dot_i16x8_s (local.get 0) (local.get 1)))
+)`);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:10
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:13
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:16
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:19
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:22
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:25
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:28
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0x1fff8000, 0x1fff8000, 0x1fff8000, 0x1fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:31
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0x20000000, 0x20000000, 0x20000000, 0x20000000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:34
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x1fff8000, 0x1fff8000, 0x1fff8000, 0x1fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:37
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x20000000, 0x20000000, 0x20000000, 0x20000000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:40
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x20008000, 0x20008000, 0x20008000, 0x20008000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:43
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xfffa, 0xfffa, 0xfffa, 0xfffa])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:46
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xfffc, 0xfffc, 0xfffc, 0xfffc])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:49
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffff0000, 0xffff0000, 0xffff0000, 0xffff0000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:52
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffc, 0xfffc, 0xfffc, 0xfffc])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:55
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:58
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x10000, 0x10000, 0x10000, 0x10000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:61
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7ffe0002, 0x7ffe0002, 0x7ffe0002, 0x7ffe0002])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:64
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:67
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x7fff0000, 0x7fff0000, 0x7fff0000, 0x7fff0000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:70
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:73
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:76
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:79
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xffff0002, 0xffff0002, 0xffff0002, 0xffff0002])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:82
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x10000, 0x10000, 0x10000, 0x10000])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:85
+assert_return(
+  () => invoke($0, `i32x4.dot_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:90
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.dot_i16x8_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:94
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.dot_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.dot_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_dot_i16x8.wast:102
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.dot_i16x8_s-arg-empty (result v128)
+      (i32x4.dot_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js
new file mode 100644
index 0000000000..910ae3c5b1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extadd_pairwise_i16x8.wast.js
@@ -0,0 +1,184 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:11
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:13
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:15
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:17
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i32x4([0xfffc, 0xfffc, 0xfffc, 0xfffc])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:19
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0xffff0002, 0xffff0002, 0xffff0002, 0xffff0002])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:21
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff0000, 0xffff0000, 0xffff0000, 0xffff0000])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:23
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:25
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:29
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:31
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:33
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1fffe, 0x1fffe, 0x1fffe, 0x1fffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:35
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i32x4([0xfffc, 0xfffc, 0xfffc, 0xfffc])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:37
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x10002, 0x10002, 0x10002, 0x10002])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:39
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x10000, 0x10000, 0x10000, 0x10000])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:41
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xfffe, 0xfffe, 0xfffe, 0xfffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:43
+assert_return(
+  () => invoke($0, `i32x4.extadd_pairwise_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1fffe, 0x1fffe, 0x1fffe, 0x1fffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:47
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extadd_pairwise_i16x8_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:48
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extadd_pairwise_i16x8_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:52
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extadd_pairwise_i16x8_s-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extadd_pairwise_i16x8.wast:60
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extadd_pairwise_i16x8_u-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js
new file mode 100644
index 0000000000..8fc1d05e97
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_extmul_i16x8.wast.js
@@ -0,0 +1,1066 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:13
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:16
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:19
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:22
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:25
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:28
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:31
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0xfffc000, 0xfffc000, 0xfffc000, 0xfffc000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:34
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:37
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0xfffc000, 0xfffc000, 0xfffc000, 0xfffc000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:40
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:43
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x10004000, 0x10004000, 0x10004000, 0x10004000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:46
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:49
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:52
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:55
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:58
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:61
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:64
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x3fff0001, 0x3fff0001, 0x3fff0001, 0x3fff0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:67
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:70
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x3fff8000, 0x3fff8000, 0x3fff8000, 0x3fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:73
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:76
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:79
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:82
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xffff8001, 0xffff8001, 0xffff8001, 0xffff8001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:85
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:88
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:93
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:96
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:99
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:102
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:105
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:108
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:111
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0xfffc000, 0xfffc000, 0xfffc000, 0xfffc000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:114
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:117
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0xfffc000, 0xfffc000, 0xfffc000, 0xfffc000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:120
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:123
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x10004000, 0x10004000, 0x10004000, 0x10004000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:126
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:129
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:132
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:135
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:138
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:141
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:144
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x3fff0001, 0x3fff0001, 0x3fff0001, 0x3fff0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:147
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:150
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x3fff8000, 0x3fff8000, 0x3fff8000, 0x3fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:153
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:156
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:159
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:162
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xffff8001, 0xffff8001, 0xffff8001, 0xffff8001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:165
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:168
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:173
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:176
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:179
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:182
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:185
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:188
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe0001, 0xfffe0001, 0xfffe0001, 0xfffe0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:191
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0xfffc000, 0xfffc000, 0xfffc000, 0xfffc000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:194
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:197
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x9000c000, 0x9000c000, 0x9000c000, 0x9000c000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:200
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x90000000, 0x90000000, 0x90000000, 0x90000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:203
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x8fff4000, 0x8fff4000, 0x8fff4000, 0x8fff4000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:206
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:209
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:212
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:215
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x80017ffe, 0x80017ffe, 0x80017ffe, 0x80017ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:218
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x80007fff, 0x80007fff, 0x80007fff, 0x80007fff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:221
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7fff8000, 0x7fff8000, 0x7fff8000, 0x7fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:224
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x3fff0001, 0x3fff0001, 0x3fff0001, 0x3fff0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:227
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:230
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x40008000, 0x40008000, 0x40008000, 0x40008000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:233
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:236
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:239
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe0001, 0xfffe0001, 0xfffe0001, 0xfffe0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:242
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7ffe8001, 0x7ffe8001, 0x7ffe8001, 0x7ffe8001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:245
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x7fff8000, 0x7fff8000, 0x7fff8000, 0x7fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:248
+assert_return(
+  () => invoke($0, `i32x4.extmul_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe0001, 0xfffe0001, 0xfffe0001, 0xfffe0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:253
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:256
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:259
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:262
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:265
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:268
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe0001, 0xfffe0001, 0xfffe0001, 0xfffe0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:271
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff, 0x3fff]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0xfffc000, 0xfffc000, 0xfffc000, 0xfffc000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:274
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+    i16x8([0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000]),
+  ]),
+  [i32x4([0x10000000, 0x10000000, 0x10000000, 0x10000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:277
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001, 0xc001]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x9000c000, 0x9000c000, 0x9000c000, 0x9000c000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:280
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x90000000, 0x90000000, 0x90000000, 0x90000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:283
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff, 0xbfff]),
+    i16x8([0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000, 0xc000]),
+  ]),
+  [i32x4([0x8fff4000, 0x8fff4000, 0x8fff4000, 0x8fff4000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:286
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffd, 0x7ffd, 0x7ffd, 0x7ffd])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:289
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:292
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:295
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002, 0x8002]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x80017ffe, 0x80017ffe, 0x80017ffe, 0x80017ffe])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:298
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x80007fff, 0x80007fff, 0x80007fff, 0x80007fff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:301
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7fff8000, 0x7fff8000, 0x7fff8000, 0x7fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:304
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x3fff0001, 0x3fff0001, 0x3fff0001, 0x3fff0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:307
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:310
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x40008000, 0x40008000, 0x40008000, 0x40008000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:313
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:316
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:319
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe0001, 0xfffe0001, 0xfffe0001, 0xfffe0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:322
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7ffe8001, 0x7ffe8001, 0x7ffe8001, 0x7ffe8001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:325
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x7fff8000, 0x7fff8000, 0x7fff8000, 0x7fff8000])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:328
+assert_return(
+  () => invoke($0, `i32x4.extmul_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xfffe0001, 0xfffe0001, 0xfffe0001, 0xfffe0001])],
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:333
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extmul_low_i16x8_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:334
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extmul_high_i16x8_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:335
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extmul_low_i16x8_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:336
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extmul_high_i16x8_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:340
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:348
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extmul_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:356
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:364
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extmul_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:372
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:380
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extmul_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:388
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i32x4_extmul_i16x8.wast:396
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extmul_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js
new file mode 100644
index 0000000000..bc24976ff9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f32x4.wast.js
@@ -0,0 +1,1016 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:10
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:12
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:14
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([1.5, 1.5, 1.5, 1.5])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:16
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-1.5, -1.5, -1.5, -1.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:18
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([1.9, 1.9, 1.9, 1.9])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:20
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([2, 2, 2, 2])]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:22
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-1.9, -1.9, -1.9, -1.9])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:24
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-2, -2, -2, -2])]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0xfffffffe, 0xfffffffe])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:26
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([2147483500, 2147483500, 2147483500, 2147483500]),
+  ]),
+  [i32x4([0x7fffff80, 0x7fffff80, 0x7fffff80, 0x7fffff80])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:28
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-2147483500, -2147483500, -2147483500, -2147483500]),
+  ]),
+  [i32x4([0x80000080, 0x80000080, 0x80000080, 0x80000080])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:30
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([2147483600, 2147483600, 2147483600, 2147483600]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:32
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-2147483600, -2147483600, -2147483600, -2147483600]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:34
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:36
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-4294967300, -4294967300, -4294967300, -4294967300]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:38
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([2147483600, 2147483600, 2147483600, 2147483600]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:40
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-2147483600, -2147483600, -2147483600, -2147483600]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:42
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:44
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:46
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:48
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:50
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:52
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:54
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:56
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:58
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:60
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([1, 1, 1, 1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:62
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-1, -1, -1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:64
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([1.1, 1.1, 1.1, 1.1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:66
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-1.1, -1.1, -1.1, -1.1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:68
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x6, 0x6, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:70
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xfffffffa, 0xfffffffa, 0xfffffffa, 0xfffffffa])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:72
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:74
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:76
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([0.9, 0.9, 0.9, 0.9])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:78
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-0.9, -0.9, -0.9, -0.9])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:80
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([0.99999994, 0.99999994, 0.99999994, 0.99999994]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:82
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-0.99999994, -0.99999994, -0.99999994, -0.99999994]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:84
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x6, 0x6, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:86
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0xfffffffa, 0xfffffffa, 0xfffffffa, 0xfffffffa])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:88
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:90
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:92
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:94
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:96
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:98
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:100
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:102
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:104
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([42, 42, 42, 42])]),
+  [i32x4([0x2a, 0x2a, 0x2a, 0x2a])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:106
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [f32x4([-42, -42, -42, -42])]),
+  [i32x4([0xffffffd6, 0xffffffd6, 0xffffffd6, 0xffffffd6])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:108
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x75bcd18, 0x75bcd18, 0x75bcd18, 0x75bcd18])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:110
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_s`, [
+    f32x4([1234568000, 1234568000, 1234568000, 1234568000]),
+  ]),
+  [i32x4([0x49960300, 0x49960300, 0x49960300, 0x49960300])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:114
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([0, 0, 0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:116
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-0, -0, -0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:118
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([1.5, 1.5, 1.5, 1.5])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:120
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-1.5, -1.5, -1.5, -1.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:122
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([1.9, 1.9, 1.9, 1.9])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:124
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([2, 2, 2, 2])]),
+  [i32x4([0x2, 0x2, 0x2, 0x2])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:126
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-1.9, -1.9, -1.9, -1.9])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:128
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-2, -2, -2, -2])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:130
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([2147483500, 2147483500, 2147483500, 2147483500]),
+  ]),
+  [i32x4([0x7fffff80, 0x7fffff80, 0x7fffff80, 0x7fffff80])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:132
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-2147483500, -2147483500, -2147483500, -2147483500]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:134
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([2147483600, 2147483600, 2147483600, 2147483600]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:136
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-2147483600, -2147483600, -2147483600, -2147483600]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:138
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:140
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-4294967300, -4294967300, -4294967300, -4294967300]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:142
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([2147483600, 2147483600, 2147483600, 2147483600]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:144
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-2147483600, -2147483600, -2147483600, -2147483600]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:146
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:148
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:150
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([4294967300, 4294967300, 4294967300, 4294967300]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:152
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+      0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:154
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+      -0.000000000000000000000000000000000000000000001,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:156
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+      0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:158
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+      -0.000000000000000000000000000000000000011754944,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:160
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([0.5, 0.5, 0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:162
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-0.5, -0.5, -0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:164
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([1, 1, 1, 1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:166
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-1, -1, -1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:168
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([1.1, 1.1, 1.1, 1.1])]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:170
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-1.1, -1.1, -1.1, -1.1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:172
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x6, 0x6, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:174
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:176
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:178
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:180
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([0.9, 0.9, 0.9, 0.9])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:182
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-0.9, -0.9, -0.9, -0.9])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:184
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([0.99999994, 0.99999994, 0.99999994, 0.99999994]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:186
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-0.99999994, -0.99999994, -0.99999994, -0.99999994]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:188
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([6.2831855, 6.2831855, 6.2831855, 6.2831855]),
+  ]),
+  [i32x4([0x6, 0x6, 0x6, 0x6])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:190
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-6.2831855, -6.2831855, -6.2831855, -6.2831855]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:192
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+      340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:194
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+      -340282350000000000000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:196
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:198
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:200
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:202
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:204
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+      0x44,
+      0x44,
+      0xc4,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:206
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+      0x44,
+      0x44,
+      0xc4,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:208
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([42, 42, 42, 42])]),
+  [i32x4([0x2a, 0x2a, 0x2a, 0x2a])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:210
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [f32x4([-42, -42, -42, -42])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:212
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([123456790, 123456790, 123456790, 123456790]),
+  ]),
+  [i32x4([0x75bcd18, 0x75bcd18, 0x75bcd18, 0x75bcd18])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:214
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f32x4_u`, [
+    f32x4([1234568000, 1234568000, 1234568000, 1234568000]),
+  ]),
+  [i32x4([0x49960300, 0x49960300, 0x49960300, 0x49960300])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:218
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.trunc_sat_f32x4_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:219
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.trunc_sat_f32x4_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:223
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.trunc_sat_f32x4_s-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f32x4.wast:231
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.trunc_sat_f32x4_u-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js
new file mode 100644
index 0000000000..72cf5568a8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i32x4_trunc_sat_f64x2.wast.js
@@ -0,0 +1,940 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:10
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:12
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:14
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([1.5, 1.5])]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:16
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-1.5, -1.5])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:18
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([1.9, 1.9])]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:20
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([2, 2])]),
+  [i32x4([0x2, 0x2, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:22
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-1.9, -1.9])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:24
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-2, -2])]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:26
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([2147483520, 2147483520])]),
+  [i32x4([0x7fffff80, 0x7fffff80, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:28
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-2147483520, -2147483520])]),
+  [i32x4([0x80000080, 0x80000080, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:30
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([2147483648, 2147483648])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:32
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-2147483648, -2147483648])]),
+  [i32x4([0x80000000, 0x80000000, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:34
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([4294967294, 4294967294])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:36
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-4294967294, -4294967294])]),
+  [i32x4([0x80000000, 0x80000000, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:38
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([2147483647, 2147483647])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:40
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-2147483647, -2147483647])]),
+  [i32x4([0x80000001, 0x80000001, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:42
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([4294967294, 4294967294])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:44
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([4294967295, 4294967295])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:46
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([4294967296, 4294967296])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:48
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000001401298464324817,
+      0.000000000000000000000000000000000000000000001401298464324817,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:50
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000001401298464324817,
+      -0.000000000000000000000000000000000000000000001401298464324817,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:52
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000011754943508222875,
+      0.000000000000000000000000000000000000011754943508222875,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:54
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000011754943508222875,
+      -0.000000000000000000000000000000000000011754943508222875,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:56
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:58
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:60
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([1, 1])]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:62
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-1, -1])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:64
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([1.100000023841858, 1.100000023841858]),
+  ]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:66
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([-1.100000023841858, -1.100000023841858]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:68
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([6.2831854820251465, 6.2831854820251465]),
+  ]),
+  [i32x4([0x6, 0x6, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:70
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([-6.2831854820251465, -6.2831854820251465]),
+  ]),
+  [i32x4([0xfffffffa, 0xfffffffa, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:72
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      340282346638528860000000000000000000000,
+      340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:74
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      -340282346638528860000000000000000000000,
+      -340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:76
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([0.8999999761581421, 0.8999999761581421]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:78
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([-0.8999999761581421, -0.8999999761581421]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:80
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([0.9999999403953552, 0.9999999403953552]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:82
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([-0.9999999403953552, -0.9999999403953552]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:84
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([6.2831854820251465, 6.2831854820251465]),
+  ]),
+  [i32x4([0x6, 0x6, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:86
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([-6.2831854820251465, -6.2831854820251465]),
+  ]),
+  [i32x4([0xfffffffa, 0xfffffffa, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:88
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      340282346638528860000000000000000000000,
+      340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:90
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    f64x2([
+      -340282346638528860000000000000000000000,
+      -340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x80000000, 0x80000000, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:92
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([Infinity, Infinity])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:94
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-Infinity, -Infinity])]),
+  [i32x4([0x80000000, 0x80000000, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:96
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:98
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:100
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x7f,
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:102
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0xff,
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:104
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([42, 42])]),
+  [i32x4([0x2a, 0x2a, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:106
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([-42, -42])]),
+  [i32x4([0xffffffd6, 0xffffffd6, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:108
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([123456792, 123456792])]),
+  [i32x4([0x75bcd18, 0x75bcd18, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:110
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_s_zero`, [f64x2([1234567890, 1234567890])]),
+  [i32x4([0x499602d2, 0x499602d2, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:114
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([0, 0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:116
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-0, -0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:118
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([1.5, 1.5])]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:120
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-1.5, -1.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:122
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([1.9, 1.9])]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:124
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([2, 2])]),
+  [i32x4([0x2, 0x2, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:126
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-1.9, -1.9])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:128
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-2, -2])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:130
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([2147483520, 2147483520])]),
+  [i32x4([0x7fffff80, 0x7fffff80, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:132
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-2147483520, -2147483520])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:134
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([2147483648, 2147483648])]),
+  [i32x4([0x80000000, 0x80000000, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:136
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-2147483648, -2147483648])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:138
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([4294967294, 4294967294])]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:140
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-4294967294, -4294967294])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:142
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([2147483647, 2147483647])]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:144
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-2147483647, -2147483647])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:146
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([4294967294, 4294967294])]),
+  [i32x4([0xfffffffe, 0xfffffffe, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:148
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([4294967295, 4294967295])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:150
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([4294967296, 4294967296])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:152
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000001401298464324817,
+      0.000000000000000000000000000000000000000000001401298464324817,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:154
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000001401298464324817,
+      -0.000000000000000000000000000000000000000000001401298464324817,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:156
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      0.000000000000000000000000000000000000011754943508222875,
+      0.000000000000000000000000000000000000011754943508222875,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:158
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      -0.000000000000000000000000000000000000011754943508222875,
+      -0.000000000000000000000000000000000000011754943508222875,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:160
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([0.5, 0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:162
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-0.5, -0.5])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:164
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([1, 1])]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:166
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-1, -1])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:168
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([1.100000023841858, 1.100000023841858]),
+  ]),
+  [i32x4([0x1, 0x1, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:170
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([-1.100000023841858, -1.100000023841858]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:172
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([6.2831854820251465, 6.2831854820251465]),
+  ]),
+  [i32x4([0x6, 0x6, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:174
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([-6.2831854820251465, -6.2831854820251465]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:176
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      340282346638528860000000000000000000000,
+      340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:178
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      -340282346638528860000000000000000000000,
+      -340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:180
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([0.8999999761581421, 0.8999999761581421]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:182
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([-0.8999999761581421, -0.8999999761581421]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:184
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([0.9999999403953552, 0.9999999403953552]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:186
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([-0.9999999403953552, -0.9999999403953552]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:188
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([6.2831854820251465, 6.2831854820251465]),
+  ]),
+  [i32x4([0x6, 0x6, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:190
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([-6.2831854820251465, -6.2831854820251465]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:192
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      340282346638528860000000000000000000000,
+      340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:194
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    f64x2([
+      -340282346638528860000000000000000000000,
+      -340282346638528860000000000000000000000,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:196
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([Infinity, Infinity])]),
+  [i32x4([0xffffffff, 0xffffffff, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:198
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-Infinity, -Infinity])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:200
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:202
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:204
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x7f,
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x7f,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:206
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [
+    bytes('v128', [
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0xff,
+      0x44,
+      0x44,
+      0x44,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:208
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([42, 42])]),
+  [i32x4([0x2a, 0x2a, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:210
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([-42, -42])]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:212
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([123456792, 123456792])]),
+  [i32x4([0x75bcd18, 0x75bcd18, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:214
+assert_return(
+  () => invoke($0, `i32x4.trunc_sat_f64x2_u_zero`, [f64x2([1234567890, 1234567890])]),
+  [i32x4([0x499602d2, 0x499602d2, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:218
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.trunc_sat_f64x2_s_zero (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:219
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.trunc_sat_f64x2_u_zero (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:223
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.trunc_sat_f64x2_s_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_s_zero)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i32x4_trunc_sat_f64x2.wast:231
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.trunc_sat_f64x2_u_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_u_zero)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js
new file mode 100644
index 0000000000..90ad748a42
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith.wast.js
@@ -0,0 +1,1753 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i64x2_arith.wast
+
+// ./test/core/simd/simd_i64x2_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i64x2_arith.wast:13
+assert_return(
+  () => invoke($0, `i64x2.add`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:16
+assert_return(
+  () => invoke($0, `i64x2.add`, [i64x2([0x0n, 0x0n]), i64x2([0x1n, 0x1n])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:19
+assert_return(
+  () => invoke($0, `i64x2.add`, [i64x2([0x1n, 0x1n]), i64x2([0x1n, 0x1n])]),
+  [i64x2([0x2n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:22
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x0n, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:25
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x1n, 0x1n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:28
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:31
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x3fffffffffffffffn, 0x3fffffffffffffffn]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:34
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:37
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xc000000000000001n, 0xc000000000000001n]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:40
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:43
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xbfffffffffffffffn, 0xbfffffffffffffffn]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:46
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7ffffffffffffffdn, 0x7ffffffffffffffdn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:49
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:52
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:55
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000002n, 0x8000000000000002n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:58
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000001n, 0x8000000000000001n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:61
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:64
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:67
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:70
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000001n, 0x8000000000000001n]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:73
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:76
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:79
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:82
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+  ]),
+  [i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:85
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:88
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:91
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x3fffffffffffffffn, 0x3fffffffffffffffn]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:94
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:97
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xc000000000000001n, 0xc000000000000001n]),
+    i64x2([0xfbfffffff0000001n, 0xfbfffffff0000001n]),
+  ]),
+  [i64x2([0xbbfffffff0000002n, 0xbbfffffff0000002n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:100
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xfc00000000000000n, 0xfc00000000000000n]),
+  ]),
+  [i64x2([0xbc00000000000000n, 0xbc00000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:103
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xfbffffffffffffffn, 0xfbffffffffffffffn]),
+  ]),
+  [i64x2([0xbbffffffffffffffn, 0xbbffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:106
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x7ffffffffffffffn, 0x7ffffffffffffffn]),
+  ]),
+  [i64x2([0x87fffffffffffffen, 0x87fffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:109
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:112
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:115
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:118
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:121
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:124
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:127
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:130
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x1n, 0x1n]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:133
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i16x8([0x0, 0x0, 0x0, 0x8000, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:136
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x1n, 0x1n]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:139
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i32x4([0x0, 0x80000000, 0x0, 0x80000000]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:142
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x1n, 0x1n]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:145
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:148
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:151
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0xbff0000000000000n, 0xbff0000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:154
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0x3ff0000000000000n, 0x3ff0000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:157
+assert_return(
+  () => invoke($0, `i64x2.add`, [i64x2([0x1n, 0x1n]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x7ff0000000000001n, 0x7ff0000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:160
+assert_return(
+  () => invoke($0, `i64x2.add`, [i64x2([0x1n, 0x1n]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xfff0000000000001n, 0xfff0000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:163
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x1n, 0x1n]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x7ff8000000000001n, 0x7ff8000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:166
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:169
+assert_return(
+  () => invoke($0, `i64x2.add`, [i64x2([0x0n, 0x1n]), i64x2([0x0n, 0x2n])]),
+  [i64x2([0x0n, 0x3n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:172
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+  ]),
+  [i64x2([0x224421e8fbd3022an, 0x224421e8fbd3022an])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:175
+assert_return(
+  () => invoke($0, `i64x2.add`, [
+    i64x2([0x1234567890abcdefn, 0x1234567890abcdefn]),
+    i64x2([0x90abcdef12345678n, 0x90abcdef12345678n]),
+  ]),
+  [i64x2([0xa2e02467a2e02467n, 0xa2e02467a2e02467n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:180
+assert_return(
+  () => invoke($0, `i64x2.sub`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:183
+assert_return(
+  () => invoke($0, `i64x2.sub`, [i64x2([0x0n, 0x0n]), i64x2([0x1n, 0x1n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:186
+assert_return(
+  () => invoke($0, `i64x2.sub`, [i64x2([0x1n, 0x1n]), i64x2([0x1n, 0x1n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:189
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x0n, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:192
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x1n, 0x1n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x2n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:195
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:198
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x3fffffffffffffffn, 0x3fffffffffffffffn]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:201
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:204
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xc000000000000001n, 0xc000000000000001n]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:207
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:210
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xbfffffffffffffffn, 0xbfffffffffffffffn]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:213
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7ffffffffffffffdn, 0x7ffffffffffffffdn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7ffffffffffffffcn, 0x7ffffffffffffffcn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:216
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7ffffffffffffffdn, 0x7ffffffffffffffdn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:219
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:222
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000002n, 0x8000000000000002n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000003n, 0x8000000000000003n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:225
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000001n, 0x8000000000000001n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000002n, 0x8000000000000002n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:228
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:231
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:234
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:237
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000001n, 0x8000000000000001n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:240
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:243
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:246
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:249
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:252
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:255
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:258
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x3fffffffffffffffn, 0x3fffffffffffffffn]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:261
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:264
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xc000000000000001n, 0xc000000000000001n]),
+    i64x2([0xfbfffffff0000001n, 0xfbfffffff0000001n]),
+  ]),
+  [i64x2([0xc400000010000000n, 0xc400000010000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:267
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xfc00000000000000n, 0xfc00000000000000n]),
+  ]),
+  [i64x2([0xc400000000000000n, 0xc400000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:270
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xfbffffffffffffffn, 0xfbffffffffffffffn]),
+  ]),
+  [i64x2([0xc400000000000001n, 0xc400000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:273
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x7ffffffffffffffn, 0x7ffffffffffffffn]),
+  ]),
+  [i64x2([0x7800000000000000n, 0x7800000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:276
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:279
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:282
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:285
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:288
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0xfffffffffffffffen, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:291
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:294
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:297
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x1n, 0x1n]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i64x2([0x2n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:300
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i16x8([0x0, 0x0, 0x0, 0x8000, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:303
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x1n, 0x1n]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i64x2([0x2n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:306
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i32x4([0x0, 0x80000000, 0x0, 0x80000000]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:309
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x1n, 0x1n]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x2n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:312
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([0, 0]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:315
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([-0, -0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:318
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([1, 1]),
+  ]),
+  [i64x2([0x4010000000000000n, 0x4010000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:321
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    f64x2([-1, -1]),
+  ]),
+  [i64x2([0xc010000000000000n, 0xc010000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:324
+assert_return(
+  () => invoke($0, `i64x2.sub`, [i64x2([0x1n, 0x1n]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x8010000000000001n, 0x8010000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:327
+assert_return(
+  () => invoke($0, `i64x2.sub`, [i64x2([0x1n, 0x1n]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0x10000000000001n, 0x10000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:330
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x1n, 0x1n]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x8008000000000001n, 0x8008000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:333
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:336
+assert_return(
+  () => invoke($0, `i64x2.sub`, [i64x2([0x0n, 0x1n]), i64x2([0x0n, 0x2n])]),
+  [i64x2([0x0n, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:339
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x2c9c7076ed2f8115n, 0x2c9c7076ed2f8115n]),
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+  ]),
+  [i64x2([0x1b7a5f826f460000n, 0x1b7a5f826f460000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:342
+assert_return(
+  () => invoke($0, `i64x2.sub`, [
+    i64x2([0x90abcdef87654321n, 0x90abcdef87654321n]),
+    i64x2([0x1234567890abcdefn, 0x1234567890abcdefn]),
+  ]),
+  [i64x2([0x7e777776f6b97532n, 0x7e777776f6b97532n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:347
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:350
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x0n, 0x0n]), i64x2([0x1n, 0x1n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:353
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x1n, 0x1n]), i64x2([0x1n, 0x1n])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:356
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x0n, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:359
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x1n, 0x1n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:362
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:365
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x3fffffffffffffffn, 0x3fffffffffffffffn]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0xc000000000000000n, 0xc000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:368
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:371
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xc000000000000001n, 0xc000000000000001n]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0xc000000000000000n, 0xc000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:374
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:377
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xbfffffffffffffffn, 0xbfffffffffffffffn]),
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+  ]),
+  [i64x2([0x4000000000000000n, 0x4000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:380
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x7ffffffffffffffdn, 0x7ffffffffffffffdn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7ffffffffffffffdn, 0x7ffffffffffffffdn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:383
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:386
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:389
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000002n, 0x8000000000000002n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:392
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000001n, 0x8000000000000001n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:395
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:398
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:401
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:404
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000001n, 0x8000000000000001n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:407
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0x0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:410
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:413
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:416
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:419
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:422
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:425
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x3fffffffffffffffn, 0x3fffffffffffffffn]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0xc000000000000000n, 0xc000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:428
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+    i64x2([0x4000000000000000n, 0x4000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:431
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xc000000000000001n, 0xc000000000000001n]),
+    i64x2([0xfbfffffff0000001n, 0xfbfffffff0000001n]),
+  ]),
+  [i64x2([0xbbfffffff0000001n, 0xbbfffffff0000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:434
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xfc00000000000000n, 0xfc00000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:437
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xc000000000000000n, 0xc000000000000000n]),
+    i64x2([0xfbffffffffffffffn, 0xfbffffffffffffffn]),
+  ]),
+  [i64x2([0x4000000000000000n, 0x4000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:440
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x7ffffffffffffffn, 0x7ffffffffffffffn]),
+  ]),
+  [i64x2([0x7800000000000001n, 0x7800000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:443
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:446
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:449
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:452
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:455
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x1n, 0x1n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:458
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:461
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:464
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:467
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i16x8([0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x2]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:470
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:473
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x8000000000000000n, 0x8000000000000000n]),
+    i32x4([0x0, 0x2, 0x0, 0x2]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:476
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:479
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x80000000n, 0x80000000n]), f64x2([0, 0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:482
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x80000000n, 0x80000000n]), f64x2([-0, -0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:485
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x80000000n, 0x80000000n]), f64x2([1, 1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:488
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x80000000n, 0x80000000n]), f64x2([-1, -1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:491
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x1n, 0x1n]), f64x2([Infinity, Infinity])]),
+  [i64x2([0x7ff0000000000000n, 0x7ff0000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:494
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x1n, 0x1n]), f64x2([-Infinity, -Infinity])]),
+  [i64x2([0xfff0000000000000n, 0xfff0000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:497
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x1n, 0x1n]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [i64x2([0x7ff8000000000000n, 0x7ff8000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:500
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:503
+assert_return(
+  () => invoke($0, `i64x2.mul`, [i64x2([0x0n, 0x1n]), i64x2([0x0n, 0x2n])]),
+  [i64x2([0x0n, 0x2n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:506
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+    i64x2([0x112210f47de98115n, 0x112210f47de98115n]),
+  ]),
+  [i64x2([0x86c28d12bb502bb9n, 0x86c28d12bb502bb9n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:509
+assert_return(
+  () => invoke($0, `i64x2.mul`, [
+    i64x2([0x1234567890abcdefn, 0x1234567890abcdefn]),
+    i64x2([0x90abcdef87654321n, 0x90abcdef87654321n]),
+  ]),
+  [i64x2([0x602f05e9e55618cfn, 0x602f05e9e55618cfn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:514
+assert_return(() => invoke($0, `i64x2.neg`, [i64x2([0x0n, 0x0n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_arith.wast:516
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x1n, 0x1n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:518
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:520
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x7ffffffffffffffen, 0x7ffffffffffffffen])]),
+  [i64x2([0x8000000000000002n, 0x8000000000000002n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:522
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x8000000000000001n, 0x8000000000000001n])]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:524
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:526
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:528
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:530
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x1n, 0x1n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:532
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:534
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:536
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x8000000000000001n, 0x8000000000000001n])]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:538
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])]),
+  [i64x2([0x8000000000000001n, 0x8000000000000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:540
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:542
+assert_return(
+  () => invoke($0, `i64x2.neg`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:546
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.neg (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:547
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.add (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:548
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:549
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:553
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.neg-arg-empty (result v128)
+      (i64x2.neg)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:561
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.add-1st-arg-empty (result v128)
+      (i64x2.add (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:569
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.add-arg-empty (result v128)
+      (i64x2.add)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:577
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.sub-1st-arg-empty (result v128)
+      (i64x2.sub (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:585
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.sub-arg-empty (result v128)
+      (i64x2.sub)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:593
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.mul-1st-arg-empty (result v128)
+      (i64x2.mul (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:601
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.mul-arg-empty (result v128)
+      (i64x2.mul)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:611
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i64x2_arith.wast:628
+assert_return(
+  () => invoke($1, `add-sub`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0x2n]),
+    i64x2([0x0n, 0x2n]),
+  ]),
+  [i64x2([0x0n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:632
+assert_return(
+  () => invoke($1, `mul-add`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x2n, 0x2n]),
+  ]),
+  [i64x2([0x0n, 0x4n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:636
+assert_return(
+  () => invoke($1, `mul-sub`, [
+    i64x2([0x0n, 0x2n]),
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0x1n]),
+  ]),
+  [i64x2([0x0n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:640
+assert_return(
+  () => invoke($1, `sub-add`, [
+    i64x2([0x0n, 0x1n]),
+    i64x2([0x0n, 0x2n]),
+    i64x2([0x0n, 0x2n]),
+  ]),
+  [i64x2([0x0n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:644
+assert_return(
+  () => invoke($1, `add-neg`, [i64x2([0x0n, 0x1n]), i64x2([0x0n, 0x1n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:647
+assert_return(
+  () => invoke($1, `mul-neg`, [i64x2([0x0n, 0x1n]), i64x2([0x2n, 0x2n])]),
+  [i64x2([0x0n, 0xfffffffffffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_arith.wast:650
+assert_return(
+  () => invoke($1, `sub-neg`, [i64x2([0x0n, 0x1n]), i64x2([0x0n, 0x1n])]),
+  [i64x2([0x0n, 0xfffffffffffffffen])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js
new file mode 100644
index 0000000000..208a463b94
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_arith2.wast.js
@@ -0,0 +1,149 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i64x2_arith2.wast
+
+// ./test/core/simd/simd_i64x2_arith2.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:8
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x1n, 0x1n])]), [i64x2([0x1n, 0x1n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:10
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:12
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:14
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:16
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:18
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:20
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:22
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0x8000000000000000n, 0x8000000000000000n])]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:24
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x7bn, 0x7bn])]), [i64x2([0x7bn, 0x7bn])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:26
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0xffffffffffffff85n, 0xffffffffffffff85n])]),
+  [i64x2([0x7bn, 0x7bn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:28
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x80n, 0x80n])]), [i64x2([0x80n, 0x80n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:30
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0xffffffffffffff80n, 0xffffffffffffff80n])]),
+  [i64x2([0x80n, 0x80n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:32
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x80n, 0x80n])]), [i64x2([0x80n, 0x80n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:34
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0xffffffffffffff80n, 0xffffffffffffff80n])]),
+  [i64x2([0x80n, 0x80n])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:38
+assert_return(
+  () => invoke($0, `i64x2.abs_with_const_0`, []),
+  [i64x2([0x8000000000000000n, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:43
+assert_return(
+  () => invoke($0, `i64x2.abs`, [i64x2([0x8000000000000000n, 0x7fffffffffffffffn])]),
+  [i64x2([0x8000000000000000n, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:47
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x0n, 0x0n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:49
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x0n, 0x0n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:51
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x0n, 0x0n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:53
+assert_return(() => invoke($0, `i64x2.abs`, [i64x2([0x0n, 0x0n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:59
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.abs (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:63
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.abs-arg-empty (result v128)
+      (i64x2.abs)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:73
+let $1 = instantiate(`(module
+  (func (export "i64x2.abs-i64x2.abs") (param v128) (result v128) (i64x2.abs (i64x2.abs (local.get 0))))
+)`);
+
+// ./test/core/simd/simd_i64x2_arith2.wast:77
+assert_return(
+  () => invoke($1, `i64x2.abs-i64x2.abs`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js
new file mode 100644
index 0000000000..9e346fa8b3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_cmp.wast.js
@@ -0,0 +1,980 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i64x2_cmp.wast
+
+// ./test/core/simd/simd_i64x2_cmp.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:17
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:20
+assert_return(
+  () => invoke($0, `eq`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:23
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:26
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:29
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:32
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:35
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0x3020100n, 0x11100904n]),
+    i64x2([0x3020100n, 0x11100904n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:38
+assert_return(
+  () => invoke($0, `eq`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xfffffffffffffffn, 0xfffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:41
+assert_return(() => invoke($0, `eq`, [i64x2([0x1n, 0x1n]), i64x2([0x2n, 0x2n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:50
+assert_return(
+  () => invoke($0, `ne`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:53
+assert_return(() => invoke($0, `ne`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:56
+assert_return(
+  () => invoke($0, `ne`, [
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:59
+assert_return(
+  () => invoke($0, `ne`, [
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:62
+assert_return(
+  () => invoke($0, `ne`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:65
+assert_return(
+  () => invoke($0, `ne`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:68
+assert_return(
+  () => invoke($0, `ne`, [
+    i64x2([0x3020100n, 0x11100904n]),
+    i64x2([0x3020100n, 0x11100904n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:77
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:80
+assert_return(
+  () => invoke($0, `lt_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:83
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:86
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:89
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:92
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:95
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:100
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:103
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:106
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:109
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:112
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:117
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:120
+assert_return(
+  () => invoke($0, `lt_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:123
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:126
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:129
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:132
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:135
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:140
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0xc060000000000000n, 0xc05fc00000000000n]),
+    f64x2([-128, -127]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:143
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i64x2([0x3ff0000000000000n, 0x405fc00000000000n]),
+    f64x2([1, 127]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:152
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:155
+assert_return(
+  () => invoke($0, `le_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:158
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:161
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:164
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:167
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:170
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:175
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:178
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:181
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:184
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:187
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:192
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:195
+assert_return(
+  () => invoke($0, `le_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0xffffffffffffffffn])]),
+  [i64x2([0xffffffffffffffffn, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:198
+assert_return(
+  () => invoke($0, `le_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:201
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:204
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:207
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:210
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:213
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:218
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0xc060000000000000n, 0xc05fc00000000000n]),
+    f64x2([-128, -127]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:221
+assert_return(
+  () => invoke($0, `le_s`, [
+    i64x2([0x3ff0000000000000n, 0x405fc00000000000n]),
+    f64x2([1, 127]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:230
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:233
+assert_return(
+  () => invoke($0, `gt_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:236
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:239
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:242
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:245
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:248
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:253
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:256
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:259
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:262
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:265
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:270
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:273
+assert_return(
+  () => invoke($0, `gt_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:276
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:279
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:282
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:285
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:288
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:293
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0xc060000000000000n, 0xc05fc00000000000n]),
+    f64x2([-128, -127]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:296
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i64x2([0x3ff0000000000000n, 0x405fc00000000000n]),
+    f64x2([1, 127]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:305
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:308
+assert_return(
+  () => invoke($0, `ge_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:311
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+    i64x2([0xf0f0f0f0f0f0f0f0n, 0xf0f0f0f0f0f0f0f0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:314
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+    i64x2([0xf0f0f0f0f0f0f0fn, 0xf0f0f0f0f0f0f0fn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:317
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:320
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:323
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+    i64x2([0x302010011100904n, 0x1a0b0a12ffabaa1bn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:328
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:331
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:334
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:337
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+    i64x2([0x8080808080808080n, 0x8080808080808080n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:340
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+    i64x2([0x8382818000fffefdn, 0x7f020100fffefd80n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:345
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:348
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0x0n, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:351
+assert_return(
+  () => invoke($0, `ge_s`, [i64x2([0x0n, 0x0n]), i64x2([0x0n, 0x0n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:354
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:357
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:360
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xffffffffffffffffn, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0x0n]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:363
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x0n, 0xffffffffffffffffn]),
+    i64x2([0x0n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:366
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+    i64x2([0x8000000000000001n, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:371
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0xc060000000000000n, 0xc05fc00000000000n]),
+    f64x2([-128, -127]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:374
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i64x2([0x3ff0000000000000n, 0x405fc00000000000n]),
+    f64x2([1, 127]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:380
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.eq (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:381
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.ne (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:382
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.ge_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:383
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.gt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:384
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.le_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:385
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.lt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:389
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.eq-1st-arg-empty (result v128)
+      (i64x2.eq (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:397
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.eq-arg-empty (result v128)
+      (i64x2.eq)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:405
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.ne-1st-arg-empty (result v128)
+      (i64x2.ne (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_cmp.wast:413
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.ne-arg-empty (result v128)
+      (i64x2.ne)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js
new file mode 100644
index 0000000000..7427c7fd0d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i64x2_extmul_i32x4.wast.js
@@ -0,0 +1,1066 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:13
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:16
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:19
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:22
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:25
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:28
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:31
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0xfffffffc0000000n, 0xfffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:34
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0x1000000000000000n, 0x1000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:37
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0xfffffffc0000000n, 0xfffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:40
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x1000000000000000n, 0x1000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:43
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x1000000040000000n, 0x1000000040000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:46
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffdn, 0x7ffffffdn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:49
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:52
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:55
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:58
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:61
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:64
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x3fffffff00000001n, 0x3fffffff00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:67
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x4000000000000000n, 0x4000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:70
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0x3fffffff80000000n, 0x3fffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:73
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:76
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:79
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:82
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0xffffffff80000001n, 0xffffffff80000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:85
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:88
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:93
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:96
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:99
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:102
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:105
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:108
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:111
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0xfffffffc0000000n, 0xfffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:114
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0x1000000000000000n, 0x1000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:117
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0xfffffffc0000000n, 0xfffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:120
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x1000000000000000n, 0x1000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:123
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x1000000040000000n, 0x1000000040000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:126
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffdn, 0x7ffffffdn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:129
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:132
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:135
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:138
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:141
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:144
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x3fffffff00000001n, 0x3fffffff00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:147
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x4000000000000000n, 0x4000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:150
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0x3fffffff80000000n, 0x3fffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:153
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:156
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:159
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:162
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0xffffffff80000001n, 0xffffffff80000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:165
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:168
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:173
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:176
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:179
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:182
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:185
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:188
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xfffffffe00000001n, 0xfffffffe00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:191
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0xfffffffc0000000n, 0xfffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:194
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0x1000000000000000n, 0x1000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:197
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x90000000c0000000n, 0x90000000c0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:200
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x9000000000000000n, 0x9000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:203
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x8fffffff40000000n, 0x8fffffff40000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:206
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffdn, 0x7ffffffdn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:209
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:212
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:215
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x800000017ffffffen, 0x800000017ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:218
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x800000007fffffffn, 0x800000007fffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:221
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7fffffff80000000n, 0x7fffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:224
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x3fffffff00000001n, 0x3fffffff00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:227
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x4000000000000000n, 0x4000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:230
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0x4000000080000000n, 0x4000000080000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:233
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:236
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:239
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xfffffffe00000001n, 0xfffffffe00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:242
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7ffffffe80000001n, 0x7ffffffe80000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:245
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x7fffffff80000000n, 0x7fffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:248
+assert_return(
+  () => invoke($0, `i64x2.extmul_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xfffffffe00000001n, 0xfffffffe00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:253
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:256
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:259
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:262
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:265
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:268
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xfffffffe00000001n, 0xfffffffe00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:271
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x3fffffff, 0x3fffffff, 0x3fffffff, 0x3fffffff]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0xfffffffc0000000n, 0xfffffffc0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:274
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+    i32x4([0x40000000, 0x40000000, 0x40000000, 0x40000000]),
+  ]),
+  [i64x2([0x1000000000000000n, 0x1000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:277
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xc0000001, 0xc0000001, 0xc0000001, 0xc0000001]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x90000000c0000000n, 0x90000000c0000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:280
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x9000000000000000n, 0x9000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:283
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xbfffffff, 0xbfffffff, 0xbfffffff, 0xbfffffff]),
+    i32x4([0xc0000000, 0xc0000000, 0xc0000000, 0xc0000000]),
+  ]),
+  [i64x2([0x8fffffff40000000n, 0x8fffffff40000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:286
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x7ffffffd, 0x7ffffffd, 0x7ffffffd, 0x7ffffffd]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffdn, 0x7ffffffdn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:289
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7ffffffe, 0x7ffffffe]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:292
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:295
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x80000002, 0x80000002, 0x80000002, 0x80000002]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x800000017ffffffen, 0x800000017ffffffen])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:298
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x800000007fffffffn, 0x800000007fffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:301
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7fffffff80000000n, 0x7fffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:304
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x3fffffff00000001n, 0x3fffffff00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:307
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x4000000000000000n, 0x4000000000000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:310
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+    i32x4([0x80000001, 0x80000001, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0x4000000080000000n, 0x4000000080000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:313
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:316
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:319
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xfffffffe00000001n, 0xfffffffe00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:322
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7ffffffe80000001n, 0x7ffffffe80000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:325
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x7fffffff80000000n, 0x7fffffff80000000n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:328
+assert_return(
+  () => invoke($0, `i64x2.extmul_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xfffffffe00000001n, 0xfffffffe00000001n])],
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:333
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extmul_low_i32x4_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:334
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extmul_high_i32x4_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:335
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extmul_low_i32x4_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:336
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extmul_high_i32x4_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:340
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_low_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:348
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:356
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_high_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:364
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:372
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_low_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:380
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:388
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_high_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i64x2_extmul_i32x4.wast:396
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extmul_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js
new file mode 100644
index 0000000000..698420ca4d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith.wast.js
@@ -0,0 +1,1457 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i8x16_arith.wast
+
+// ./test/core/simd/simd_i8x16_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i8x16_arith.wast:12
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:15
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:18
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:21
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:24
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:27
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:30
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:33
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:36
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:39
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:42
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:45
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:48
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:51
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:54
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:57
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:60
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:63
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:66
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:69
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:72
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:75
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:78
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:81
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:84
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:87
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:90
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:93
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:96
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:99
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:102
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:105
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:108
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:111
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:114
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:117
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:120
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:123
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:126
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:129
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:132
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:135
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:138
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:141
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:144
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x0, 0xbf, 0x80, 0x80, 0x0, 0xbf, 0x80, 0x80, 0x0, 0xbf, 0x80, 0x80, 0x0, 0xbf]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:147
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x0, 0x3f, 0x80, 0x80, 0x0, 0x3f, 0x80, 0x80, 0x0, 0x3f, 0x80, 0x80, 0x0, 0x3f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:150
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x80, 0x1, 0x1, 0x81, 0x80, 0x1, 0x1, 0x81, 0x80, 0x1, 0x1, 0x81, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:153
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x0, 0x1, 0x1, 0x81, 0x0, 0x1, 0x1, 0x81, 0x0, 0x1, 0x1, 0x81, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:156
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0xc1, 0x80, 0x1, 0x1, 0xc1, 0x80, 0x1, 0x1, 0xc1, 0x80, 0x1, 0x1, 0xc1, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:159
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:162
+assert_return(
+  () => invoke($0, `i8x16.add`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1e, 0x21, 0x24, 0x27, 0x2a, 0x2d]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:167
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:170
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:173
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:176
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:179
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:182
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:185
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:188
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:191
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:194
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:197
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:200
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:203
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:206
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:209
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:212
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:215
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:218
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:221
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:224
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:227
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:230
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:233
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:236
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:239
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:242
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:245
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:248
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:251
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:254
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:257
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:260
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:263
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:266
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:269
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:272
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:275
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:278
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:281
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i16x8([0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080, 0x8080]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:284
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:287
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i32x4([0x80808080, 0x80808080, 0x80808080, 0x80808080]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:290
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:293
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([0, 0, 0, 0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:296
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:299
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([1, 1, 1, 1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x0, 0x41, 0x80, 0x80, 0x0, 0x41, 0x80, 0x80, 0x0, 0x41, 0x80, 0x80, 0x0, 0x41]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:302
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-1, -1, -1, -1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x0, 0xc1, 0x80, 0x80, 0x0, 0xc1, 0x80, 0x80, 0x0, 0xc1, 0x80, 0x80, 0x0, 0xc1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:305
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x82, 0x1, 0x1, 0x81, 0x82, 0x1, 0x1, 0x81, 0x82, 0x1, 0x1, 0x81, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:308
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x2, 0x1, 0x1, 0x81, 0x2, 0x1, 0x1, 0x81, 0x2, 0x1, 0x1, 0x81, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:311
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x41, 0x82, 0x1, 0x1, 0x41, 0x82, 0x1, 0x1, 0x41, 0x82, 0x1, 0x1, 0x41, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:314
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:317
+assert_return(
+  () => invoke($0, `i8x16.sub`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:322
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:324
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:326
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:328
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:330
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:332
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:334
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:336
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:338
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:340
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:342
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:344
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:346
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:348
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:350
+assert_return(
+  () => invoke($0, `i8x16.neg`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:354
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.neg (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:355
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:356
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:360
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.neg-arg-empty (result v128)
+      (i8x16.neg)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:368
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:376
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.add-arg-empty (result v128)
+      (i8x16.add)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:384
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:392
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.sub-arg-empty (result v128)
+      (i8x16.sub)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:402
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i8x16_arith.wast:413
+assert_return(
+  () => invoke($1, `add-sub`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:417
+assert_return(
+  () => invoke($1, `sub-add`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:421
+assert_return(
+  () => invoke($1, `add-neg`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith.wast:424
+assert_return(
+  () => invoke($1, `sub-neg`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0xfe, 0xfc, 0xfa, 0xf8, 0xf6, 0xf4, 0xf2, 0xf0, 0xee, 0xec, 0xea, 0xe8, 0xe6, 0xe4, 0xe2]),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js
new file mode 100644
index 0000000000..7d8d376765
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_arith2.wast.js
@@ -0,0 +1,2263 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i8x16_arith2.wast
+
+// ./test/core/simd/simd_i8x16_arith2.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:35
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:38
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:41
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:44
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:47
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:50
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:53
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:56
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:59
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:62
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:65
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:68
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:71
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:74
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:77
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:80
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:83
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:86
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:89
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:92
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:95
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:98
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:101
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:104
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:107
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:110
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:113
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:116
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:119
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:122
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:125
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:128
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:131
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:134
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:137
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:140
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:143
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:146
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:149
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:152
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:155
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:158
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:161
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:164
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:167
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:170
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:173
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:176
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:179
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:182
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:185
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:188
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:191
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:194
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:197
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:200
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:202
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:204
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:206
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:208
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:210
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:212
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:214
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:216
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:218
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85]),
+  ]),
+  [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:220
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:222
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:224
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:226
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:228
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:230
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:232
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:234
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:236
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:238
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:240
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:242
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:244
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b, 0x7b]),
+  ]),
+  [
+    i8x16([0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:246
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85]),
+  ]),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:248
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:250
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:252
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:254
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:258
+assert_return(
+  () => invoke($0, `i8x16.min_s_with_const_0`, []),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:259
+assert_return(
+  () => invoke($0, `i8x16.min_s_with_const_1`, []),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:260
+assert_return(
+  () => invoke($0, `i8x16.min_u_with_const_2`, []),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:261
+assert_return(
+  () => invoke($0, `i8x16.min_u_with_const_3`, []),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:262
+assert_return(
+  () => invoke($0, `i8x16.max_s_with_const_4`, []),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:263
+assert_return(
+  () => invoke($0, `i8x16.max_s_with_const_5`, []),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:264
+assert_return(
+  () => invoke($0, `i8x16.max_u_with_const_6`, []),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:265
+assert_return(
+  () => invoke($0, `i8x16.max_u_with_const_7`, []),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:266
+assert_return(
+  () => invoke($0, `i8x16.avgr_u_with_const_8`, []),
+  [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:267
+assert_return(
+  () => invoke($0, `i8x16.avgr_u_with_const_9`, []),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:268
+assert_return(
+  () => invoke($0, `i8x16.abs_with_const_10`, []),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:269
+assert_return(
+  () => invoke($0, `i8x16.popcnt_with_const_11`, []),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x7, 0x7, 0x7, 0x7, 0x1, 0x1, 0x1, 0x1, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:272
+assert_return(
+  () => invoke($0, `i8x16.min_s_with_const_12`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:274
+assert_return(
+  () => invoke($0, `i8x16.min_s_with_const_13`, [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:276
+assert_return(
+  () => invoke($0, `i8x16.min_u_with_const_14`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:278
+assert_return(
+  () => invoke($0, `i8x16.min_u_with_const_15`, [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:280
+assert_return(
+  () => invoke($0, `i8x16.max_s_with_const_16`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:282
+assert_return(
+  () => invoke($0, `i8x16.max_s_with_const_17`, [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:284
+assert_return(
+  () => invoke($0, `i8x16.max_u_with_const_18`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:286
+assert_return(
+  () => invoke($0, `i8x16.max_u_with_const_19`, [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:288
+assert_return(
+  () => invoke($0, `i8x16.avgr_u_with_const_20`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:290
+assert_return(
+  () => invoke($0, `i8x16.avgr_u_with_const_21`, [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:294
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:297
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:300
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:303
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:306
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:309
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:312
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:315
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:318
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0x40, 0x40, 0x40, 0x40, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:321
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x1, 0x1, 0x1, 0x1, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:324
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:326
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x40, 0x40, 0x40, 0x40, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x7, 0x7, 0x7, 0x7, 0x1, 0x1, 0x1, 0x1, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:330
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:333
+assert_return(
+  () => invoke($0, `i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:336
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:339
+assert_return(
+  () => invoke($0, `i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:342
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:345
+assert_return(
+  () => invoke($0, `i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:348
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:351
+assert_return(
+  () => invoke($0, `i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:354
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:357
+assert_return(
+  () => invoke($0, `i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:360
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:362
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:364
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:366
+assert_return(
+  () => invoke($0, `i8x16.abs`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:368
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:370
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:372
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:374
+assert_return(
+  () => invoke($0, `i8x16.popcnt`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:378
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:379
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:380
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:381
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:382
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:383
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:386
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:387
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:388
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:389
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:390
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.avgr_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:391
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.abs (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:392
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.popcnt (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:396
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:404
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.min_s-arg-empty (result v128)
+      (i8x16.min_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:412
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:420
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.min_u-arg-empty (result v128)
+      (i8x16.min_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:428
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:436
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.max_s-arg-empty (result v128)
+      (i8x16.max_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:444
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:452
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.max_u-arg-empty (result v128)
+      (i8x16.max_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:460
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:468
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.avgr_u-arg-empty (result v128)
+      (i8x16.avgr_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:476
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.abs-arg-empty (result v128)
+      (i8x16.abs)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:484
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.popcnt-arg-empty (result v128)
+      (i8x16.popcnt)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:494
+let $1 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:546
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:550
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:554
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:558
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:562
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:566
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:569
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:572
+assert_return(
+  () => invoke($1, `i8x16.min_s-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:575
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:578
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:582
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:586
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:590
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:594
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:598
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:601
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:604
+assert_return(
+  () => invoke($1, `i8x16.min_u-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:607
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:610
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:614
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:618
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:622
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:626
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:630
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:633
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:636
+assert_return(
+  () => invoke($1, `i8x16.max_s-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:639
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:642
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:646
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:650
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:654
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:658
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:662
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:665
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:668
+assert_return(
+  () => invoke($1, `i8x16.max_u-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:671
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:674
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:678
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.max_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:682
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.max_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:686
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.min_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:690
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.min_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:694
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:697
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:700
+assert_return(
+  () => invoke($1, `i8x16.avgr_u-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:703
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.avgr_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:706
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:708
+assert_return(
+  () => invoke($1, `i8x16.abs-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:710
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.popcnt`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_arith2.wast:712
+assert_return(
+  () => invoke($1, `i8x16.popcnt-i8x16.abs`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js
new file mode 100644
index 0000000000..7cd76b5e0e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_cmp.wast.js
@@ -0,0 +1,4989 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i8x16_cmp.wast
+
+// ./test/core/simd/simd_i8x16_cmp.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:23
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:26
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:29
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:32
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:35
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:38
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:41
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:46
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:49
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:52
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:55
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:58
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:63
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:66
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:69
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:72
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:75
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:78
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:81
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:86
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:89
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:94
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:97
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:100
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:103
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:106
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:111
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:114
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:117
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:120
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:123
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:126
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:129
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:134
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:137
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:140
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:143
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:146
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:149
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:152
+assert_return(
+  () => invoke($0, `eq`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:161
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:164
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:167
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:170
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:173
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:176
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:179
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:184
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:187
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:190
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:193
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:196
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:201
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:204
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:207
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:210
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:213
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:216
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:219
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:224
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:227
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:232
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:235
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:238
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:241
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:244
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:249
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:252
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:255
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:258
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:261
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:264
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:267
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:272
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:275
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:278
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:281
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:284
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:287
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:290
+assert_return(
+  () => invoke($0, `ne`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:299
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:302
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:305
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:308
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:311
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:314
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:317
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:322
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:325
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:328
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:331
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:334
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:339
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:342
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:345
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:348
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:351
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:354
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:357
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:362
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:365
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:370
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:373
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:376
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:379
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:382
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:387
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:390
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:393
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:396
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:399
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:402
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:405
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:410
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:413
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:416
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:419
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:422
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:425
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:428
+assert_return(
+  () => invoke($0, `lt_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:437
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:440
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:443
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:446
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:449
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:452
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:455
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:460
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:463
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:466
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:469
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:472
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:477
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:480
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:483
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:486
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:489
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:492
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:495
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:500
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:503
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:508
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:511
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:514
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:517
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:520
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:525
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:528
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:531
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:534
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:537
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:540
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:543
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:548
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:551
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:554
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:557
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:560
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:563
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:566
+assert_return(
+  () => invoke($0, `lt_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:575
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:578
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:581
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:584
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:587
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:590
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:593
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:598
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:601
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:604
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:607
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:610
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:615
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:618
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:621
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:624
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:627
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:630
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:633
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:638
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:641
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:646
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:649
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:652
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:655
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:658
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:663
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:666
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:669
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:672
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:675
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:678
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:681
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:686
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:689
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:692
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:695
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:698
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:701
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:704
+assert_return(
+  () => invoke($0, `le_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:713
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:716
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:719
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:722
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:725
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:728
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:731
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:736
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:739
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:742
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:745
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:748
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:753
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:756
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:759
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:762
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:765
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:768
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:771
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:776
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:779
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:784
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:787
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:790
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:793
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:796
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:801
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:804
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:807
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:810
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:813
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:816
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:819
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:824
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:827
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:830
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:833
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:836
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:839
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:842
+assert_return(
+  () => invoke($0, `le_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:851
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:854
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:857
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:860
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:863
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:866
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:869
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:874
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:877
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:880
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:883
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:886
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:891
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:894
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:897
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:900
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:903
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:906
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:909
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:914
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:917
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:922
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:925
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:928
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:931
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:934
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:939
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:942
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:945
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:948
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:951
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:954
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:957
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:962
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:965
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:968
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:971
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:974
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:977
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:980
+assert_return(
+  () => invoke($0, `gt_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:989
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:992
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:995
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:998
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1001
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1004
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1007
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1012
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1015
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1018
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1021
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1024
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1029
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1032
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1035
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1038
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1041
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1044
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1047
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1052
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1055
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1060
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1063
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1066
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1069
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1072
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1077
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1080
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1083
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1086
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1089
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1092
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1095
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1100
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1103
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1106
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1109
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1112
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1115
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1118
+assert_return(
+  () => invoke($0, `gt_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1127
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1130
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1133
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1136
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1139
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1142
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1145
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1150
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1153
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1156
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1159
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1162
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1167
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1170
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1173
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1176
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1179
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1182
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1185
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1190
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1193
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1198
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1201
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1204
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1207
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1210
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1215
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1218
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1221
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1224
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1227
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1230
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0xff, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1233
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1238
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1241
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1244
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1247
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1250
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1253
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1256
+assert_return(
+  () => invoke($0, `ge_s`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1265
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1268
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1271
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1274
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1277
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1280
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1283
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1288
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1291
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1294
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1297
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1300
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1305
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1308
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1311
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1314
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1317
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1320
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1323
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1328
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0xc3, 0x0, 0x0, 0xfe, 0xc2, 0x0, 0x0, 0x80, 0xbf, 0x0, 0x0, 0x0, 0x0]),
+    f32x4([-128, -127, -1, 0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1331
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x80, 0x3f, 0x0, 0x0, 0xfe, 0x42, 0x0, 0x0, 0x0, 0x43, 0x0, 0x0, 0x7f, 0x43]),
+    f32x4([1, 127, 128, 255]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1336
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1339
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1342
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x9, 0x10, 0x11, 0x12, 0xa, 0xb, 0x1a, 0x1b, 0xaa, 0xab, 0xff]),
+    i8x16([0xff, 0xab, 0xaa, 0x1b, 0x1a, 0xb, 0xa, 0x12, 0x11, 0x10, 0x9, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1345
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1348
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i8x16([0xff, 0xfe, 0xfd, 0x80, 0x7f, 0x2, 0x1, 0x0, 0x0, 0xff, 0xfe, 0xfd, 0x83, 0x82, 0x81, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1353
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1356
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1359
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1362
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1365
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i16x8([0x8180, 0x8382, 0xfefd, 0xff, 0x100, 0x7f02, 0xfd80, 0xfffe]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1368
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i16x8([0xff80, 0xff80, 0x0, 0x0, 0x1, 0x1, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0xff, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1371
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i16x8([0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa, 0xaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1376
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1379
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1382
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1385
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1388
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x81, 0x82, 0x83, 0xfd, 0xfe, 0xff, 0x0, 0x0, 0x1, 0x2, 0x7f, 0x80, 0xfd, 0xfe, 0xff]),
+    i32x4([0x83828180, 0xfffefd, 0x7f020100, 0xfffefd80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1391
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff]),
+    i32x4([0xffffff80, 0x0, 0x1, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1394
+assert_return(
+  () => invoke($0, `ge_u`, [
+    i8x16([0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55]),
+    i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1401
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.eq (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1402
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.ge_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1403
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.ge_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1404
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.gt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1405
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.gt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1406
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.le_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1407
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.le_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1408
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.lt_s (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1409
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.lt_u (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1410
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.ne (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1415
+let $1 = instantiate(`(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))
+          )
+        )
+      )
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1671
+assert_return(() => invoke($1, `eq-in-block`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1672
+assert_return(() => invoke($1, `ne-in-block`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1673
+assert_return(() => invoke($1, `lt_s-in-block`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1674
+assert_return(() => invoke($1, `le_u-in-block`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1675
+assert_return(() => invoke($1, `gt_u-in-block`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1676
+assert_return(() => invoke($1, `ge_s-in-block`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1677
+assert_return(() => invoke($1, `nested-eq`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1678
+assert_return(() => invoke($1, `nested-ne`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1679
+assert_return(() => invoke($1, `nested-lt_s`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1680
+assert_return(() => invoke($1, `nested-le_u`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1681
+assert_return(() => invoke($1, `nested-gt_u`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1682
+assert_return(() => invoke($1, `nested-ge_s`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1683
+assert_return(() => invoke($1, `as-param`, []), []);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1688
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1696
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.eq-arg-empty (result v128)
+      (i8x16.eq)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1704
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1712
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.ne-arg-empty (result v128)
+      (i8x16.ne)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1720
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1728
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.lt_s-arg-empty (result v128)
+      (i8x16.lt_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1736
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1744
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.lt_u-arg-empty (result v128)
+      (i8x16.lt_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1752
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1760
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.le_s-arg-empty (result v128)
+      (i8x16.le_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1768
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1776
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.le_u-arg-empty (result v128)
+      (i8x16.le_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1784
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1792
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.gt_s-arg-empty (result v128)
+      (i8x16.gt_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1800
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1808
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.gt_u-arg-empty (result v128)
+      (i8x16.gt_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1816
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1824
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.ge_s-arg-empty (result v128)
+      (i8x16.ge_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1832
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_cmp.wast:1840
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.ge_u-arg-empty (result v128)
+      (i8x16.ge_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js
new file mode 100644
index 0000000000..856ea0d8d3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_i8x16_sat_arith.wast.js
@@ -0,0 +1,2430 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:13
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:16
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:19
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:22
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:25
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:28
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:31
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:34
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:37
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:40
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:43
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:46
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:49
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:52
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:55
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:58
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:61
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:64
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:67
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:70
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:73
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:76
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:79
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:82
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:85
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:88
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:91
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:94
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:97
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:100
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:103
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:106
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:109
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:112
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:115
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:118
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:121
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:124
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:127
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:130
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x7f, 0x1, 0x1, 0x81, 0x7f, 0x1, 0x1, 0x81, 0x7f, 0x1, 0x1, 0x81, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:133
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x0, 0x1, 0x1, 0x81, 0x0, 0x1, 0x1, 0x81, 0x0, 0x1, 0x1, 0x81, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:136
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0xc1, 0x7f, 0x1, 0x1, 0xc1, 0x7f, 0x1, 0x1, 0xc1, 0x7f, 0x1, 0x1, 0xc1, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:139
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0xc1, 0x0, 0x1, 0x1, 0xc1, 0x0, 0x1, 0x1, 0xc1, 0x0, 0x1, 0x1, 0xc1, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:142
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:145
+assert_return(
+  () => invoke($0, `i8x16.add_sat_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1e, 0x21, 0x24, 0x27, 0x2a, 0x2d]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:150
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:153
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:156
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:159
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:162
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:165
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:168
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:171
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:174
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:177
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:180
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:183
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:186
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:189
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:192
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:195
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:198
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:201
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:204
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:207
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:210
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:213
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:216
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:219
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:222
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:225
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:228
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:231
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:234
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:237
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:240
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:243
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:246
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:249
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:252
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:255
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:258
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:261
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:264
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0xff, 0x80, 0x80, 0x80, 0xff, 0x80, 0x80, 0x80, 0xff, 0x80, 0x80, 0x80, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:267
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0x80, 0x1, 0x1, 0x81, 0x80, 0x1, 0x1, 0x81, 0x80, 0x1, 0x1, 0x81, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:270
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x81, 0xff, 0x1, 0x1, 0x81, 0xff, 0x1, 0x1, 0x81, 0xff, 0x1, 0x1, 0x81, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:273
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0xc1, 0x80, 0x1, 0x1, 0xc1, 0x80, 0x1, 0x1, 0xc1, 0x80, 0x1, 0x1, 0xc1, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:276
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0xc1, 0xff, 0x1, 0x1, 0xc1, 0xff, 0x1, 0x1, 0xc1, 0xff, 0x1, 0x1, 0xc1, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:279
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:282
+assert_return(
+  () => invoke($0, `i8x16.add_sat_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1e, 0x21, 0x24, 0x27, 0x2a, 0x2d]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:287
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:290
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:293
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:296
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:299
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:302
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:305
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:308
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:311
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:314
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:317
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:320
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:323
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:326
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:329
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:332
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:335
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:338
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:341
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:344
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:347
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:350
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:353
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:356
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:359
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:362
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:365
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:368
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:371
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:374
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:377
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:380
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:383
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:386
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:389
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:392
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:395
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:398
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:401
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:404
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x7f, 0x82, 0x1, 0x1, 0x7f, 0x82, 0x1, 0x1, 0x7f, 0x82, 0x1, 0x1, 0x7f, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:407
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x7f, 0x2, 0x1, 0x1, 0x7f, 0x2, 0x1, 0x1, 0x7f, 0x2, 0x1, 0x1, 0x7f, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:410
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x41, 0x82, 0x1, 0x1, 0x41, 0x82, 0x1, 0x1, 0x41, 0x82, 0x1, 0x1, 0x41, 0x82]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:413
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x41, 0x2, 0x1, 0x1, 0x41, 0x2, 0x1, 0x1, 0x41, 0x2, 0x1, 0x1, 0x41, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:416
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ]),
+  [
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:419
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_s`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:424
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:427
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:430
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:433
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:436
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:439
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:442
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:445
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:448
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:451
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:454
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:457
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:460
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d, 0x7d]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:463
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:466
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:469
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:472
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:475
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:478
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:481
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:484
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:487
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:490
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:493
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:496
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:499
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:502
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:505
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:508
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:511
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:514
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0]),
+    i8x16([0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:517
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:520
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:523
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:526
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:529
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:532
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:535
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:538
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    f32x4([-0, -0, -0, -0]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0, 0x80, 0x80, 0x80, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:541
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([Infinity, Infinity, Infinity, Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:544
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    f32x4([-Infinity, -Infinity, -Infinity, -Infinity]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:547
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:550
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+    ]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0, 0x1, 0x1, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:553
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:556
+assert_return(
+  () => invoke($0, `i8x16.sub_sat_u`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:561
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:564
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:567
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:570
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:573
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.add_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:576
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.add_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:579
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.sub_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:582
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.sub_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:585
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.add_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:588
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.add_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:591
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.sub_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:594
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.sub_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:599
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.add_sat_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:600
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.add_sat_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:601
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.sub_sat_s (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:602
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.sub_sat_u (i32.const 0) (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:606
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:614
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.add_sat_s-arg-empty (result v128)
+      (i8x16.add_sat_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:622
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:630
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.add_sat_u-arg-empty (result v128)
+      (i8x16.add_sat_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:638
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:646
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.sub_sat_s-arg-empty (result v128)
+      (i8x16.sub_sat_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:654
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:662
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.sub_sat_u-arg-empty (result v128)
+      (i8x16.sub_sat_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:672
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:691
+assert_return(
+  () => invoke($1, `sat-add_s-sub_s`, [
+    i8x16([0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:695
+assert_return(
+  () => invoke($1, `sat-add_s-sub_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:699
+assert_return(
+  () => invoke($1, `sat-add_u-sub_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:703
+assert_return(
+  () => invoke($1, `sat-add_u-sub_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:707
+assert_return(
+  () => invoke($1, `sat-add_s-neg`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:710
+assert_return(
+  () => invoke($1, `sat-add_u-neg`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:713
+assert_return(
+  () => invoke($1, `sat-sub_s-neg`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_i8x16_sat_arith.wast:716
+assert_return(
+  () => invoke($1, `sat-sub_u-neg`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js
new file mode 100644
index 0000000000..0f5a430e5a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_int_to_int_extend.wast.js
@@ -0,0 +1,2026 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_int_to_int_extend.wast
+
+// ./test/core/simd/simd_int_to_int_extend.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:18
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:20
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:22
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:24
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:26
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:28
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:30
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:32
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:34
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:36
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:38
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:40
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:42
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:44
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:46
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:48
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:50
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:52
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:54
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:57
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:59
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:61
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:63
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:65
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:67
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:69
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:71
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:73
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:75
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:77
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:79
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:81
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:83
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:85
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:87
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:89
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:91
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:93
+assert_return(
+  () => invoke($0, `i16x8.extend_high_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:96
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:98
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:100
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:102
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:104
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:106
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:108
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:110
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:112
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:114
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:116
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:118
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:120
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:122
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:124
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:126
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81, 0xff81])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:128
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:130
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80, 0xff80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:132
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_s`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:135
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:137
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:139
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:141
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:143
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:145
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:147
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:149
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:151
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:153
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:155
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:157
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:159
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:161
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:163
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:165
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:167
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:169
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [i16x8([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:171
+assert_return(
+  () => invoke($0, `i16x8.extend_low_i8x16_u`, [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ]),
+  [i16x8([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:174
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:176
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:178
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:180
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:182
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:184
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:186
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:188
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:190
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:192
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:194
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:196
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:198
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:200
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:202
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:204
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:206
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0xffff8001, 0xffff8001, 0xffff8001, 0xffff8001])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:208
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:210
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:213
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:215
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:217
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:219
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:221
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:223
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:225
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:227
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:229
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:231
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:233
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:235
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:237
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:239
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:241
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:243
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:245
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:247
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:249
+assert_return(
+  () => invoke($0, `i32x4.extend_high_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:252
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:254
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:256
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:258
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:260
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:262
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:264
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:266
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:268
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:270
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:272
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:274
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:276
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:278
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:280
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:282
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff8001, 0xffff8001, 0xffff8001, 0xffff8001])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:284
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:286
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0xffff8000, 0xffff8000, 0xffff8000, 0xffff8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:288
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_s`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:291
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:293
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:295
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:297
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:299
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:301
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x1, 0x1, 0x1, 0x1, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:303
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x1, 0x1, 0x1, 0x1]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:305
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:307
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7ffe, 0x7ffe, 0x7ffe, 0x7ffe]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:309
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:311
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:313
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:315
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:317
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:319
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x7fff, 0x7fff, 0x7fff, 0x7fff]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:321
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x8001, 0x8001, 0x8001, 0x8001, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0x8001, 0x8001, 0x8001, 0x8001])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:323
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8001, 0x8001, 0x8001]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:325
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i32x4([0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:327
+assert_return(
+  () => invoke($0, `i32x4.extend_low_i16x8_u`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x8000, 0x8000, 0x8000, 0x8000]),
+  ]),
+  [i32x4([0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:330
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:332
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [i32x4([0x0, 0x0, 0x1, 0x1])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:334
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:336
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [i32x4([0x1, 0x1, 0x0, 0x0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:338
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:340
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x1, 0x1, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:342
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x1, 0x1]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:344
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:346
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7ffffffe, 0x7ffffffe]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:348
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:350
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:352
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:354
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:356
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:358
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:360
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x80000001, 0x80000001, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:362
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0xffffffff80000001n, 0xffffffff80000001n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:364
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:366
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:369
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:371
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [i32x4([0x0, 0x0, 0x1, 0x1])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:373
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:375
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [i32x4([0x1, 0x1, 0x0, 0x0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:377
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:379
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x1, 0x1, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:381
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x1, 0x1]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:383
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:385
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7ffffffe, 0x7ffffffe]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:387
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:389
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:391
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:393
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:395
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:397
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:399
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x80000001, 0x80000001, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:401
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0x80000001n, 0x80000001n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:403
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:405
+assert_return(
+  () => invoke($0, `i64x2.extend_high_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:408
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:410
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [i32x4([0x0, 0x0, 0x1, 0x1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:412
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:414
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [i32x4([0x1, 0x1, 0x0, 0x0])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:416
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:418
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x1, 0x1, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:420
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:422
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:424
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7ffffffe, 0x7ffffffe]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:426
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:428
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:430
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:432
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:434
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:436
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:438
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x80000001, 0x80000001, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffff80000001n, 0xffffffff80000001n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:440
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:442
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0x80000000, 0x80000000, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0xffffffff80000000n, 0xffffffff80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:444
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_s`, [
+    i32x4([0xffffffff, 0xffffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:447
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:449
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [i32x4([0x0, 0x0, 0x1, 0x1])]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:451
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x0n, 0x0n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:453
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [i32x4([0x1, 0x1, 0x0, 0x0])]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:455
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x0, 0x0]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:457
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x1, 0x1, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x1n, 0x1n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:459
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x1, 0x1]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:461
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x7ffffffe, 0x7ffffffe, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7ffffffen, 0x7ffffffen])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:463
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7ffffffe, 0x7ffffffe]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:465
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:467
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:469
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:471
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:473
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x7fffffff, 0x7fffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x7fffffffn, 0x7fffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:475
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x7fffffff, 0x7fffffff]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:477
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x80000001, 0x80000001, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0x80000001n, 0x80000001n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:479
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0x80000001, 0x80000001]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:481
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0x80000000, 0x80000000, 0xffffffff, 0xffffffff]),
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:483
+assert_return(
+  () => invoke($0, `i64x2.extend_low_i32x4_u`, [
+    i32x4([0xffffffff, 0xffffffff, 0x80000000, 0x80000000]),
+  ]),
+  [i64x2([0xffffffffn, 0xffffffffn])],
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:488
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extend_high_i8x16_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:489
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extend_high_i8x16_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:490
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extend_low_i8x16_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:491
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.extend_low_i8x16_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:492
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extend_high_i16x8_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:493
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extend_high_i16x8_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:494
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extend_low_i16x8_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:495
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.extend_low_i16x8_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:496
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extend_high_i32x4_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:497
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extend_high_i32x4_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:498
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extend_low_i32x4_s (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:499
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.extend_low_i32x4_u (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:503
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extend_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:511
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extend_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:519
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extend_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:527
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extend_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:535
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extend_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:543
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extend_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:551
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extend_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:559
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extend_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:567
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extend_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:575
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extend_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:583
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extend_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_int_to_int_extend.wast:591
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extend_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js
new file mode 100644
index 0000000000..614e722fb7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_lane.wast.js
@@ -0,0 +1,4349 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_lane.wast
+
+// ./test/core/simd/simd_lane.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_lane.wast:81
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_s-first`, [
+    i8x16([0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 127)],
+);
+
+// ./test/core/simd/simd_lane.wast:82
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_s-first`, [
+    i8x16([0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 127)],
+);
+
+// ./test/core/simd/simd_lane.wast:83
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_s-first`, [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:84
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_s-first`, [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:85
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_u-first`, [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 255)],
+);
+
+// ./test/core/simd/simd_lane.wast:86
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_u-first`, [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 255)],
+);
+
+// ./test/core/simd/simd_lane.wast:87
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_s-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [value("i32", -128)],
+);
+
+// ./test/core/simd/simd_lane.wast:88
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_s-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [value("i32", -128)],
+);
+
+// ./test/core/simd/simd_lane.wast:89
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_u-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff]),
+  ]),
+  [value("i32", 255)],
+);
+
+// ./test/core/simd/simd_lane.wast:90
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_u-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff]),
+  ]),
+  [value("i32", 255)],
+);
+
+// ./test/core/simd/simd_lane.wast:91
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_u-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [value("i32", 128)],
+);
+
+// ./test/core/simd/simd_lane.wast:92
+assert_return(
+  () => invoke($0, `i8x16_extract_lane_u-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [value("i32", 128)],
+);
+
+// ./test/core/simd/simd_lane.wast:94
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-first`, [
+    i16x8([0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 32767)],
+);
+
+// ./test/core/simd/simd_lane.wast:95
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-first`, [
+    i16x8([0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 32767)],
+);
+
+// ./test/core/simd/simd_lane.wast:96
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-first`, [
+    i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:97
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-first`, [
+    i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:98
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-first`, [
+    i16x8([0x3039, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 12345)],
+);
+
+// ./test/core/simd/simd_lane.wast:99
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-first`, [
+    i16x8([0xedcc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", -4660)],
+);
+
+// ./test/core/simd/simd_lane.wast:100
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-first`, [
+    i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 65535)],
+);
+
+// ./test/core/simd/simd_lane.wast:101
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-first`, [
+    i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 65535)],
+);
+
+// ./test/core/simd/simd_lane.wast:102
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-first`, [
+    i16x8([0x3039, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 12345)],
+);
+
+// ./test/core/simd/simd_lane.wast:103
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-first`, [
+    i16x8([0xedcc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 60876)],
+);
+
+// ./test/core/simd/simd_lane.wast:104
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [value("i32", -32768)],
+);
+
+// ./test/core/simd/simd_lane.wast:105
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [value("i32", -32768)],
+);
+
+// ./test/core/simd/simd_lane.wast:106
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a85]),
+  ]),
+  [value("i32", 6789)],
+);
+
+// ./test/core/simd/simd_lane.wast:107
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_s-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9877]),
+  ]),
+  [value("i32", -26505)],
+);
+
+// ./test/core/simd/simd_lane.wast:108
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff]),
+  ]),
+  [value("i32", 65535)],
+);
+
+// ./test/core/simd/simd_lane.wast:109
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff]),
+  ]),
+  [value("i32", 65535)],
+);
+
+// ./test/core/simd/simd_lane.wast:110
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [value("i32", 32768)],
+);
+
+// ./test/core/simd/simd_lane.wast:111
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [value("i32", 32768)],
+);
+
+// ./test/core/simd/simd_lane.wast:112
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1a85]),
+  ]),
+  [value("i32", 6789)],
+);
+
+// ./test/core/simd/simd_lane.wast:113
+assert_return(
+  () => invoke($0, `i16x8_extract_lane_u-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9877]),
+  ]),
+  [value("i32", 39031)],
+);
+
+// ./test/core/simd/simd_lane.wast:115
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-first`, [i32x4([0x7fffffff, 0x0, 0x0, 0x0])]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/simd/simd_lane.wast:116
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-first`, [i32x4([0x7fffffff, 0x0, 0x0, 0x0])]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/simd/simd_lane.wast:117
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-first`, [i32x4([0xffffffff, 0x0, 0x0, 0x0])]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:118
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-first`, [i32x4([0xffffffff, 0x0, 0x0, 0x0])]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:119
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-first`, [i32x4([0x499602d2, 0x0, 0x0, 0x0])]),
+  [value("i32", 1234567890)],
+);
+
+// ./test/core/simd/simd_lane.wast:120
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-first`, [i32x4([0xedcba988, 0x0, 0x0, 0x0])]),
+  [value("i32", -305419896)],
+);
+
+// ./test/core/simd/simd_lane.wast:121
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0x80000000])]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/simd/simd_lane.wast:122
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0x80000000])]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/simd/simd_lane.wast:123
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0xffffffff])]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:124
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0xffffffff])]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:125
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0x3ade68b1])]),
+  [value("i32", 987654321)],
+);
+
+// ./test/core/simd/simd_lane.wast:126
+assert_return(
+  () => invoke($0, `i32x4_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0xedcba988])]),
+  [value("i32", -305419896)],
+);
+
+// ./test/core/simd/simd_lane.wast:128
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-first`, [i64x2([0x7fffffffffffffffn, 0x0n])]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/simd/simd_lane.wast:129
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-first`, [i64x2([0x7ffffffffffffffen, 0x0n])]),
+  [value("i64", 9223372036854775806n)],
+);
+
+// ./test/core/simd/simd_lane.wast:130
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-first`, [i64x2([0xffffffffffffffffn, 0x0n])]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/simd/simd_lane.wast:131
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-first`, [i64x2([0xffffffffffffffffn, 0x0n])]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/simd/simd_lane.wast:132
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-first`, [i64x2([0x112210f47de98115n, 0x0n])]),
+  [value("i64", 1234567890123456789n)],
+);
+
+// ./test/core/simd/simd_lane.wast:133
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-first`, [i64x2([0x1234567890abcdefn, 0x0n])]),
+  [value("i64", 1311768467294899695n)],
+);
+
+// ./test/core/simd/simd_lane.wast:134
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [i64x2([0x0n, 0x8000000000000000n])]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/simd/simd_lane.wast:135
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [i64x2([0x0n, 0x8000000000000000n])]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/simd/simd_lane.wast:136
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [i64x2([0x0n, 0x8000000000000000n])]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/simd/simd_lane.wast:137
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]),
+  ]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/simd/simd_lane.wast:138
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000]),
+  ]),
+  [value("i64", -9223372036854775808n)],
+);
+
+// ./test/core/simd/simd_lane.wast:139
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0x7fffffff]),
+  ]),
+  [value("i64", 9223372036854775807n)],
+);
+
+// ./test/core/simd/simd_lane.wast:140
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [f64x2([-Infinity, Infinity])]),
+  [value("i64", 9218868437227405312n)],
+);
+
+// ./test/core/simd/simd_lane.wast:141
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [i64x2([0x0n, 0x112210f47de98115n])]),
+  [value("i64", 1234567890123456789n)],
+);
+
+// ./test/core/simd/simd_lane.wast:142
+assert_return(
+  () => invoke($0, `i64x2_extract_lane-last`, [i64x2([0x0n, 0x1234567890abcdefn])]),
+  [value("i64", 1311768467294899695n)],
+);
+
+// ./test/core/simd/simd_lane.wast:144
+assert_return(() => invoke($0, `f32x4_extract_lane-first`, [f32x4([-5, 0, 0, 0])]), [value("f32", -5)]);
+
+// ./test/core/simd/simd_lane.wast:145
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [
+    f32x4([100000000000000000000000000000000000000, 0, 0, 0]),
+  ]),
+  [value("f32", 100000000000000000000000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:146
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [
+    f32x4([340282350000000000000000000000000000000, 0, 0, 0]),
+  ]),
+  [value("f32", 340282350000000000000000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:147
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [
+    f32x4([170141180000000000000000000000000000000, 0, 0, 0]),
+  ]),
+  [value("f32", 170141180000000000000000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:148
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [f32x4([Infinity, 0, 0, 0])]),
+  [value("f32", Infinity)],
+);
+
+// ./test/core/simd/simd_lane.wast:149
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x80,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/simd/simd_lane.wast:150
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [
+    f32x4([1234567900000000000000000000, 0, 0, 0]),
+  ]),
+  [value("f32", 1234567900000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:151
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-first`, [f32x4([156374990000, 0, 0, 0])]),
+  [value("f32", 156374990000)],
+);
+
+// ./test/core/simd/simd_lane.wast:152
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [
+    f32x4([0, 0, 0, -100000000000000000000000000000000000000]),
+  ]),
+  [value("f32", -100000000000000000000000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:153
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [
+    f32x4([0, 0, 0, -340282350000000000000000000000000000000]),
+  ]),
+  [value("f32", -340282350000000000000000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:154
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [
+    f32x4([0, 0, 0, -170141180000000000000000000000000000000]),
+  ]),
+  [value("f32", -170141180000000000000000000000000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:155
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [f32x4([0, 0, 0, -Infinity])]),
+  [value("f32", -Infinity)],
+);
+
+// ./test/core/simd/simd_lane.wast:156
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x80,
+      0xff,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])],
+);
+
+// ./test/core/simd/simd_lane.wast:157
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [f32x4([0, 0, 0, 123456790])]),
+  [value("f32", 123456790)],
+);
+
+// ./test/core/simd/simd_lane.wast:158
+assert_return(
+  () => invoke($0, `f32x4_extract_lane-last`, [f32x4([0, 0, 0, 81985530000000000])]),
+  [value("f32", 81985530000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:160
+assert_return(() => invoke($0, `f64x2_extract_lane-first`, [f64x2([-1.5, 0])]), [value("f64", -1.5)]);
+
+// ./test/core/simd/simd_lane.wast:161
+assert_return(() => invoke($0, `f64x2_extract_lane-first`, [f64x2([1.5, 0])]), [value("f64", 1.5)]);
+
+// ./test/core/simd/simd_lane.wast:162
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155,
+      0,
+    ]),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:163
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155,
+      0,
+    ]),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623155),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:164
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    f64x2([
+      -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0,
+    ]),
+  ]),
+  [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:165
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    f64x2([
+      0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014,
+      0,
+    ]),
+  ]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:166
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [f64x2([-Infinity, 0])]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/simd/simd_lane.wast:167
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [f64x2([Infinity, 0])]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/simd/simd_lane.wast:168
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x80,
+    ]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/simd/simd_lane.wast:169
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/simd/simd_lane.wast:170
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [
+    f64x2([1234567890123456900000000000, 0]),
+  ]),
+  [value("f64", 1234567890123456900000000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:171
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-first`, [f64x2([2623536934927580700, 0])]),
+  [value("f64", 2623536934927580700)],
+);
+
+// ./test/core/simd/simd_lane.wast:172
+assert_return(() => invoke($0, `f64x2_extract_lane-last`, [f64x2([0, 2.25])]), [value("f64", 2.25)]);
+
+// ./test/core/simd/simd_lane.wast:173
+assert_return(() => invoke($0, `f64x2_extract_lane-last`, [f64x2([0, -2.25])]), [value("f64", -2.25)]);
+
+// ./test/core/simd/simd_lane.wast:174
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    f64x2([
+      0,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:175
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    f64x2([
+      0,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:176
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    f64x2([
+      0,
+      -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:177
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    f64x2([
+      0,
+      179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+    ]),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:178
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [f64x2([-0, -Infinity])]),
+  [value("f64", -Infinity)],
+);
+
+// ./test/core/simd/simd_lane.wast:179
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [f64x2([0, Infinity])]),
+  [value("f64", Infinity)],
+);
+
+// ./test/core/simd/simd_lane.wast:180
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x80,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff])],
+);
+
+// ./test/core/simd/simd_lane.wast:181
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f])],
+);
+
+// ./test/core/simd/simd_lane.wast:182
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [f64x2([0, 123456789])]),
+  [value("f64", 123456789)],
+);
+
+// ./test/core/simd/simd_lane.wast:183
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [f64x2([0, 1375488932539311400000000])]),
+  [value("f64", 1375488932539311400000000)],
+);
+
+// ./test/core/simd/simd_lane.wast:185
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("f64", 0)],
+);
+
+// ./test/core/simd/simd_lane.wast:186
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ]),
+  [value("f64", -0)],
+);
+
+// ./test/core/simd/simd_lane.wast:187
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4000]),
+  ]),
+  [value("f64", 2)],
+);
+
+// ./test/core/simd/simd_lane.wast:188
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc000]),
+  ]),
+  [value("f64", -2)],
+);
+
+// ./test/core/simd/simd_lane.wast:189
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [
+    i32x4([0x0, 0x0, 0xffffffff, 0x7fefffff]),
+  ]),
+  [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:190
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [i32x4([0x0, 0x0, 0x0, 0x100000])]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:191
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [i32x4([0x0, 0x0, 0xffffffff, 0xfffff])]),
+  [
+    value("f64", 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:192
+assert_return(
+  () => invoke($0, `f64x2_extract_lane-last`, [i32x4([0x0, 0x0, 0x1, 0x0])]),
+  [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:194
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-first`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    127,
+  ]),
+  [
+    i8x16([0x7f, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:195
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-first`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    128,
+  ]),
+  [
+    i8x16([0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:196
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-first`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    255,
+  ]),
+  [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:197
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-first`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    256,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:198
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -128,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:199
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -129,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:200
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    32767,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:201
+assert_return(
+  () => invoke($0, `i8x16_replace_lane-last`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -32768,
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:203
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-first`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    32767,
+  ]),
+  [i16x8([0x7fff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:204
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-first`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    32768,
+  ]),
+  [i16x8([0x8000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:205
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-first`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    65535,
+  ]),
+  [i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:206
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-first`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    65536,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:207
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-first`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    12345,
+  ]),
+  [i16x8([0x3039, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:208
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-first`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -4660,
+  ]),
+  [i16x8([0xedcc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:209
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -32768,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8000])],
+);
+
+// ./test/core/simd/simd_lane.wast:210
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -32769,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7fff])],
+);
+
+// ./test/core/simd/simd_lane.wast:211
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    2147483647,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xffff])],
+);
+
+// ./test/core/simd/simd_lane.wast:212
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -2147483648,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:213
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    54321,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd431])],
+);
+
+// ./test/core/simd/simd_lane.wast:214
+assert_return(
+  () => invoke($0, `i16x8_replace_lane-last`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    -17185,
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xbcdf])],
+);
+
+// ./test/core/simd/simd_lane.wast:216
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-first`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    2147483647,
+  ]),
+  [i32x4([0x7fffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:217
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-first`, [i32x4([0x0, 0x0, 0x0, 0x0]), -1]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:218
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-first`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    1234567890,
+  ]),
+  [i32x4([0x499602d2, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:219
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-first`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    -305419896,
+  ]),
+  [i32x4([0xedcba988, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:220
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-last`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    -2147483648,
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x80000000])],
+);
+
+// ./test/core/simd/simd_lane.wast:221
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-last`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    -2147483648,
+  ]),
+  [i32x4([0x0, 0x0, 0x0, 0x80000000])],
+);
+
+// ./test/core/simd/simd_lane.wast:222
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-last`, [i32x4([0x0, 0x0, 0x0, 0x0]), 1234567890]),
+  [i32x4([0x0, 0x0, 0x0, 0x499602d2])],
+);
+
+// ./test/core/simd/simd_lane.wast:223
+assert_return(
+  () => invoke($0, `i32x4_replace_lane-last`, [i32x4([0x0, 0x0, 0x0, 0x0]), -305419896]),
+  [i32x4([0x0, 0x0, 0x0, 0xedcba988])],
+);
+
+// ./test/core/simd/simd_lane.wast:225
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [f32x4([0, 0, 0, 0]), value("f32", 53)]),
+  [
+    new F32x4Pattern(
+      value("f32", 53),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:226
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    value("f32", 53),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 53),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:227
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([0, 0, 0, 0]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:228
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", Infinity),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:229
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    value("f32", 3.14),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.14),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:230
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([Infinity, 0, 0, 0]),
+    value("f32", 100000000000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 100000000000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:231
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([Infinity, 0, 0, 0]),
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:232
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([Infinity, 0, 0, 0]),
+    value("f32", 170141180000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 170141180000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:233
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 123456790),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:234
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 123456790),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:235
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 81985530000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:236
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-first`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 81985530000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:237
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [f32x4([0, 0, 0, 0]), value("f32", -53)]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", -53),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:238
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    value("f32", -53),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", -53),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:239
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, 0]),
+    bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:240
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", -Infinity),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:241
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+    value("f32", 3.14),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 3.14),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:242
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, -Infinity]),
+    value("f32", -100000000000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", -100000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:243
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, -Infinity]),
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:244
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, -Infinity]),
+    value("f32", -170141180000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", -170141180000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:245
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 1234567900000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:246
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 1234567900000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:247
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 42984030000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:248
+assert_return(
+  () => invoke($0, `f32x4_replace_lane-last`, [
+    f32x4([0, 0, 0, 0]),
+    value("f32", 156374990000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:250
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-first`, [
+    i64x2([0x0n, 0x0n]),
+    9223372036854775807n,
+  ]),
+  [i64x2([0x7fffffffffffffffn, 0x0n])],
+);
+
+// ./test/core/simd/simd_lane.wast:251
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-first`, [i64x2([0x0n, 0x0n]), -1n]),
+  [i64x2([0xffffffffffffffffn, 0x0n])],
+);
+
+// ./test/core/simd/simd_lane.wast:252
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-first`, [
+    i64x2([0x0n, 0x0n]),
+    1234567890123456789n,
+  ]),
+  [i64x2([0x112210f47de98115n, 0x0n])],
+);
+
+// ./test/core/simd/simd_lane.wast:253
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-first`, [
+    i64x2([0x0n, 0x0n]),
+    1311768467294899695n,
+  ]),
+  [i64x2([0x1234567890abcdefn, 0x0n])],
+);
+
+// ./test/core/simd/simd_lane.wast:254
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-last`, [
+    i64x2([0x0n, 0x0n]),
+    -9223372036854775808n,
+  ]),
+  [i64x2([0x0n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_lane.wast:255
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-last`, [
+    i64x2([0x0n, 0x0n]),
+    -9223372036854775808n,
+  ]),
+  [i64x2([0x0n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_lane.wast:256
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-last`, [
+    i64x2([0x0n, 0x0n]),
+    1234567890123456789n,
+  ]),
+  [i64x2([0x0n, 0x112210f47de98115n])],
+);
+
+// ./test/core/simd/simd_lane.wast:257
+assert_return(
+  () => invoke($0, `i64x2_replace_lane-last`, [
+    i64x2([0x0n, 0x0n]),
+    1311768467294899695n,
+  ]),
+  [i64x2([0x0n, 0x1234567890abcdefn])],
+);
+
+// ./test/core/simd/simd_lane.wast:259
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([1, 1]), value("f64", 0)]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_lane.wast:260
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([-1, -1]), value("f64", -0)]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_lane.wast:261
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([0, 0]), value("f64", 1.25)]),
+  [new F64x2Pattern(value("f64", 1.25), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:262
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([0, 0]), value("f64", -1.25)]),
+  [new F64x2Pattern(value("f64", -1.25), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:263
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:264
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+    ]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:265
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    f64x2([-Infinity, 0]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:266
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    f64x2([Infinity, 0]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:267
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    f64x2([0, 0]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:268
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    f64x2([0, 0]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:269
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([0, 0]), value("f64", -Infinity)]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:270
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([0, 0]), value("f64", Infinity)]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:271
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([0, 0]), value("f64", 123456789)]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:272
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [f64x2([0, 0]), value("f64", 123456789)]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:273
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    f64x2([0, 0]),
+    value("f64", 1375488932539311400000000),
+  ]),
+  [new F64x2Pattern(value("f64", 1375488932539311400000000), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:274
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-first`, [
+    f64x2([0, 0]),
+    value("f64", 1375488932539311400000000),
+  ]),
+  [new F64x2Pattern(value("f64", 1375488932539311400000000), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:275
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [f64x2([2, 2]), value("f64", 0)]),
+  [new F64x2Pattern(value("f64", 2), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:276
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [f64x2([-2, -2]), value("f64", -0)]),
+  [new F64x2Pattern(value("f64", -2), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_lane.wast:277
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [f64x2([0, 0]), value("f64", 2.25)]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 2.25))],
+);
+
+// ./test/core/simd/simd_lane.wast:278
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [f64x2([0, 0]), value("f64", -2.25)]),
+  [new F64x2Pattern(value("f64", 0), value("f64", -2.25))],
+);
+
+// ./test/core/simd/simd_lane.wast:279
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0xff,
+    ]),
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:280
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:281
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, -Infinity]),
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:282
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, Infinity]),
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:283
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, 0]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:284
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, 0]),
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:285
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [f64x2([0, 0]), value("f64", -Infinity)]),
+  [new F64x2Pattern(value("f64", 0), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_lane.wast:286
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [f64x2([0, 0]), value("f64", Infinity)]),
+  [new F64x2Pattern(value("f64", 0), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_lane.wast:287
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, 0]),
+    value("f64", 1234567890000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 0), value("f64", 1234567890000000000000000000)),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:288
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, 0]),
+    value("f64", 1234567890000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 0), value("f64", 1234567890000000000000000000)),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:289
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, 0]),
+    value("f64", 1234567890000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(value("f64", 0), value("f64", 1234567890000000000000000000)),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:290
+assert_return(
+  () => invoke($0, `f64x2_replace_lane-last`, [
+    f64x2([0, 0]),
+    value("f64", 0.0000000000123456789),
+  ]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0.0000000000123456789))],
+);
+
+// ./test/core/simd/simd_lane.wast:292
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i8x16([0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [
+    i8x16([0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:296
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:300
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i8x16([0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73]),
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0x73, 0x72, 0x71, 0x70, 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68, 0x67, 0x66, 0x65, 0x64]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:304
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i8x16([0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73]),
+    i8x16([0xff, 0x1, 0xfe, 0x2, 0xfd, 0x3, 0xfc, 0x4, 0xfb, 0x5, 0xfa, 0x6, 0xf9, 0x7, 0xf8, 0x8]),
+  ]),
+  [
+    i8x16([0x0, 0x65, 0x0, 0x66, 0x0, 0x67, 0x0, 0x68, 0x0, 0x69, 0x0, 0x6a, 0x0, 0x6b, 0x0, 0x6c]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:308
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i8x16([0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73]),
+    i8x16([0x9, 0x10, 0xa, 0x11, 0xb, 0x12, 0xc, 0x13, 0xd, 0x14, 0xe, 0x15, 0xf, 0x16, 0x10, 0x17]),
+  ]),
+  [
+    i8x16([0x6d, 0x0, 0x6e, 0x0, 0x6f, 0x0, 0x70, 0x0, 0x71, 0x0, 0x72, 0x0, 0x73, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:312
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i8x16([0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73]),
+    i8x16([0x9, 0x10, 0xa, 0x11, 0xb, 0x12, 0xc, 0x13, 0xd, 0x14, 0xe, 0x15, 0xf, 0x16, 0x10, 0x17]),
+  ]),
+  [
+    i8x16([0x6d, 0x0, 0x6e, 0x0, 0x6f, 0x0, 0x70, 0x0, 0x71, 0x0, 0x72, 0x0, 0x73, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:316
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i16x8([0x6465, 0x6667, 0x6869, 0x6a6b, 0x6c6d, 0x6e6f, 0x7071, 0x7273]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i16x8([0x6465, 0x6667, 0x6869, 0x6a6b, 0x6c6d, 0x6e6f, 0x7071, 0x7273])],
+);
+
+// ./test/core/simd/simd_lane.wast:320
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i32x4([0x64656667, 0x68696a6b, 0x6c6d6e6f, 0x70717273]),
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [i32x4([0x73727170, 0x6f6e6d6c, 0x6b6a6968, 0x67666564])],
+);
+
+// ./test/core/simd/simd_lane.wast:324
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0xff,
+      0x0,
+      0x0,
+      0x80,
+      0x7f,
+      0x0,
+      0x0,
+      0x80,
+      0xff,
+    ]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x7fc00000, 0xffc00000, 0x7f800000, 0xff800000])],
+);
+
+// ./test/core/simd/simd_lane.wast:328
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i32x4([0x67666564, 0x6b6a6968, 0x6f6e6d5c, 0x73727170]),
+    f32x4([0, -0, Infinity, -Infinity]),
+  ]),
+  [i32x4([0x64646464, 0x646464, 0x6464, 0x6464])],
+);
+
+// ./test/core/simd/simd_lane.wast:333
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:337
+assert_return(
+  () => invoke($0, `v8x16_shuffle-2`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:341
+assert_return(
+  () => invoke($0, `v8x16_shuffle-3`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:345
+assert_return(
+  () => invoke($0, `v8x16_shuffle-4`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:349
+assert_return(
+  () => invoke($0, `v8x16_shuffle-5`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:353
+assert_return(
+  () => invoke($0, `v8x16_shuffle-6`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:357
+assert_return(
+  () => invoke($0, `v8x16_shuffle-7`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:361
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    i8x16([0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [
+    i8x16([0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:365
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+  ]),
+  [i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e])],
+);
+
+// ./test/core/simd/simd_lane.wast:369
+assert_return(
+  () => invoke($0, `v8x16_shuffle-2`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i32x4([0xf3f2f1f0, 0xf7f6f5f4, 0xfbfaf9f8, 0xfffefdfc]),
+  ]),
+  [i32x4([0xf3f2f1f0, 0xf7f6f5f4, 0xfbfaf9f8, 0xfffefdfc])],
+);
+
+// ./test/core/simd/simd_lane.wast:373
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    i32x4([0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f])],
+);
+
+// ./test/core/simd/simd_lane.wast:377
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x80,
+      0x3f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x80,
+      0x7f,
+      0x0,
+      0x0,
+      0x80,
+      0xff,
+    ]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x3f800000, 0x7fc00000, 0x7f800000, 0xff800000])],
+);
+
+// ./test/core/simd/simd_lane.wast:381
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    i32x4([0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f]),
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x80,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0x80,
+      0x7f,
+      0x0,
+      0x0,
+      0x80,
+      0xff,
+    ]),
+  ]),
+  [i32x4([0x10203, 0x4050607, 0x8090a0b, 0xc0d0e0f])],
+);
+
+// ./test/core/simd/simd_lane.wast:387
+assert_return(
+  () => invoke($0, `v8x16_swizzle`, [
+    i32x4([0x499602d2, 0x12345678, 0x499602d2, 0x12345678]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [i32x4([0x499602d2, 0x12345678, 0x499602d2, 0x12345678])],
+);
+
+// ./test/core/simd/simd_lane.wast:391
+assert_return(
+  () => invoke($0, `v8x16_shuffle-1`, [
+    i64x2([0xab54a98ceb1f0ad2n, 0x1234567890abcdefn]),
+    i64x2([0xab54a98ceb1f0ad2n, 0x1234567890abcdefn]),
+  ]),
+  [i32x4([0xeb1f0ad2, 0xab54a98c, 0x90abcdef, 0x12345678])],
+);
+
+// ./test/core/simd/simd_lane.wast:398
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:399
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:400
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane_s  -1 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:401
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane_u  -1 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:402
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32x4.extract_lane  -1 (v128.const i32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:403
+assert_malformed(
+  () => instantiate(`(func (result f32) (f32x4.extract_lane  -1 (v128.const f32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:404
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:405
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.replace_lane  -1 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:406
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.replace_lane  -1 (v128.const i32x4 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:407
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.replace_lane  -1 (v128.const f32x4 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:408
+assert_malformed(
+  () => instantiate(`(func (result i64) (i64x2.extract_lane  -1 (v128.const i64x2 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:409
+assert_malformed(
+  () => instantiate(`(func (result f64) (f64x2.extract_lane  -1 (v128.const f64x2 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:410
+assert_malformed(
+  () => instantiate(`(func (result v128) (i64x2.replace_lane  -1 (v128.const i64x2 0 0) (i64.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:411
+assert_malformed(
+  () => instantiate(`(func (result v128) (f64x2.replace_lane  -1 (v128.const f64x2 0 0) (f64.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:415
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:416
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:417
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:418
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:419
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:420
+assert_malformed(
+  () => instantiate(`(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:421
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:422
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:423
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0) (i32.const 1))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:424
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0) (i32.const 1))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:425
+assert_malformed(
+  () => instantiate(`(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:426
+assert_malformed(
+  () => instantiate(`(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:427
+assert_malformed(
+  () => instantiate(`(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0) (i64.const 1))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:428
+assert_malformed(
+  () => instantiate(`(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0) (f64.const 1))) `),
+  `malformed lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:432
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:433
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:434
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:435
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:436
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:437
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:438
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:439
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:440
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:441
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:442
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:443
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:444
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:445
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:446
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:447
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:448
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:449
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:450
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (f32.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:451
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (f32.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:452
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:453
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:454
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:455
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:456
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:457
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0) (i64.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:458
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:459
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0) (f64.const 1.0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:463
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:464
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:465
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:466
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:467
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:468
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:469
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:470
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:471
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:472
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:473
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1.0))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_lane.wast:477
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:478
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:479
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:480
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:481
+assert_invalid(
+  () => instantiate(`(module (func (result i32) (i32x4.extract_lane 0 (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:482
+assert_invalid(
+  () => instantiate(`(module (func (result f32) (f32x4.extract_lane 0 (f32.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:483
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i8x16.replace_lane 0 (i32.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:484
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i16x8.replace_lane 0 (i64.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:485
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:486
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:487
+assert_invalid(
+  () => instantiate(`(module (func (result i64) (i64x2.extract_lane 0 (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:488
+assert_invalid(
+  () => instantiate(`(module (func (result f64) (f64x2.extract_lane 0 (f64.const 0.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:489
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:490
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:494
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:495
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:496
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0) (f32.const 1.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:497
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:499
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0) (f64.const 1.0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:500
+assert_invalid(
+  () => instantiate(`(module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:503
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:505
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:507
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:510
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:515
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:518
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:521
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:525
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:529
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:536
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:537
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_lane.wast:538
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_lane.wast:539
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_lane.wast:540
+assert_malformed(
+  () => instantiate(`(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_lane.wast:541
+assert_malformed(
+  () => instantiate(`(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_lane.wast:545
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:549
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:555
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:559
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:570
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:571
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:572
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:573
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:574
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i32) (i32x4.extract_lane (local.get 0) (v128.const i32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:575
+assert_malformed(
+  () => instantiate(`(func (param i32) (result f32) (f32x4.extract_lane (local.get 0) (v128.const f32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:576
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:577
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:578
+assert_malformed(
+  () => instantiate(`(func (param i32) (result v128) (i32x4.replace_lane (local.get 0) (v128.const i32x4 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:579
+assert_malformed(
+  () => instantiate(`(func (param i32) (result v128) (f32x4.replace_lane (local.get 0) (v128.const f32x4 0 0 0 0) (f32.const 1.0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:581
+assert_malformed(
+  () => instantiate(`(func (param i32) (result i64) (i64x2.extract_lane (local.get 0) (v128.const i64x2 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:582
+assert_malformed(
+  () => instantiate(`(func (param i32) (result f64) (f64x2.extract_lane (local.get 0) (v128.const f64x2 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:583
+assert_malformed(
+  () => instantiate(`(func (param i32) (result v128) (i64x2.replace_lane (local.get 0) (v128.const i64x2 0 0) (i64.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:584
+assert_malformed(
+  () => instantiate(`(func (param i32) (result v128) (f64x2.replace_lane (local.get 0) (v128.const f64x2 0 0) (f64.const 1.0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:588
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:589
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:590
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:591
+assert_malformed(
+  () => instantiate(`(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:592
+assert_malformed(
+  () => instantiate(`(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:593
+assert_malformed(
+  () => instantiate(`(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:594
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:595
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:596
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:597
+assert_malformed(
+  () => instantiate(`(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0) (f32.const 1.1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:600
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:604
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:608
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:612
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:616
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:620
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:628
+let $1 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_lane.wast:674
+assert_return(
+  () => invoke($1, `i8x16_extract_lane_s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:675
+assert_return(
+  () => invoke($1, `i8x16_extract_lane_u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ]),
+  [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:676
+assert_return(
+  () => invoke($1, `i16x8_extract_lane_s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:677
+assert_return(
+  () => invoke($1, `i16x8_extract_lane_u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff]),
+  ]),
+  [i16x8([0xffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:678
+assert_return(
+  () => invoke($1, `i32x4_extract_lane`, [
+    i32x4([0x0, 0x0, 0x0, 0x0]),
+    i32x4([0x10000, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [i32x4([0x10000, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:679
+assert_return(
+  () => invoke($1, `f32x4_extract_lane`, [
+    f32x4([0, 0, 0, 0]),
+    bytes('v128', [
+      0x99,
+      0x76,
+      0x96,
+      0x7e,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 100000000000000000000000000000000000000),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:680
+assert_return(
+  () => invoke($1, `i8x16_replace_lane-s`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    255,
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:681
+assert_return(
+  () => invoke($1, `i8x16_replace_lane-u`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    255,
+  ]),
+  [value("i32", 255)],
+);
+
+// ./test/core/simd/simd_lane.wast:682
+assert_return(
+  () => invoke($1, `i16x8_replace_lane-s`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    65535,
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:683
+assert_return(
+  () => invoke($1, `i16x8_replace_lane-u`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    65535,
+  ]),
+  [value("i32", 65535)],
+);
+
+// ./test/core/simd/simd_lane.wast:684
+assert_return(
+  () => invoke($1, `i32x4_replace_lane`, [i32x4([0x0, 0x0, 0x0, 0x0]), -1]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:685
+assert_return(
+  () => invoke($1, `f32x4_replace_lane`, [f32x4([0, 0, 0, 0]), value("f32", 1.25)]),
+  [value("f32", 1.25)],
+);
+
+// ./test/core/simd/simd_lane.wast:687
+assert_return(
+  () => invoke($1, `i64x2_extract_lane`, [
+    i64x2([0x0n, 0x0n]),
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [i64x2([0xffffffffffffffffn, 0x0n])],
+);
+
+// ./test/core/simd/simd_lane.wast:688
+assert_return(
+  () => invoke($1, `f64x2_extract_lane`, [
+    f64x2([0, 0]),
+    bytes('v128', [
+      0xa0,
+      0xc8,
+      0xeb,
+      0x85,
+      0xf3,
+      0xcc,
+      0xe1,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:689
+assert_return(() => invoke($1, `i64x2_replace_lane`, [i64x2([0x0n, 0x0n]), -1n]), [value("i64", -1n)]);
+
+// ./test/core/simd/simd_lane.wast:690
+assert_return(
+  () => invoke($1, `f64x2_replace_lane`, [f64x2([0, 0]), value("f64", 2.5)]),
+  [value("f64", 2.5)],
+);
+
+// ./test/core/simd/simd_lane.wast:692
+assert_return(
+  () => invoke($1, `as-v8x16_swizzle-operand`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    255,
+    i8x16([0xff, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1]),
+  ]),
+  [
+    i8x16([0x0, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:696
+assert_return(
+  () => invoke($1, `as-v8x16_shuffle-operands`, [
+    i8x16([0x0, 0xff, 0x0, 0xff, 0xf, 0xff, 0x0, 0xff, 0xff, 0xff, 0x0, 0xff, 0x7f, 0xff, 0x0, 0xff]),
+    1,
+    i8x16([0x55, 0x0, 0x55, 0x0, 0x55, 0x0, 0x55, 0x0, 0x55, 0x0, 0x55, 0x0, 0x55, 0x1, 0x55, 0xff]),
+    0,
+  ]),
+  [
+    i8x16([0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:703
+let $2 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_lane.wast:750
+assert_return(
+  () => invoke($2, `as-i8x16_splat-operand`, [
+    i8x16([0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:751
+assert_return(
+  () => invoke($2, `as-i16x8_splat-operand`, [
+    i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_lane.wast:752
+assert_return(
+  () => invoke($2, `as-i32x4_splat-operand`, [i32x4([0x10000, 0x0, 0x0, 0x0])]),
+  [i32x4([0x10000, 0x10000, 0x10000, 0x10000])],
+);
+
+// ./test/core/simd/simd_lane.wast:753
+assert_return(
+  () => invoke($2, `as-f32x4_splat-operand`, [
+    bytes('v128', [
+      0xc3,
+      0xf5,
+      0x48,
+      0x40,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+      0x0,
+      0x0,
+      0xc0,
+      0x7f,
+    ]),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.14),
+      value("f32", 3.14),
+      value("f32", 3.14),
+      value("f32", 3.14),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:754
+assert_return(
+  () => invoke($2, `as-i64x2_splat-operand`, [i64x2([0xffffffffffffffffn, 0x0n])]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_lane.wast:755
+assert_return(
+  () => invoke($2, `as-f64x2_splat-operand`, [
+    bytes('v128', [
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf0,
+      0x7f,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0x0,
+      0xf8,
+      0x7f,
+    ]),
+  ]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_lane.wast:756
+assert_return(
+  () => invoke($2, `as-i8x16_add-operands`, [
+    i8x16([0xff, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10]),
+    1,
+    i8x16([0x10, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xff]),
+    1,
+  ]),
+  [
+    i8x16([0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:760
+assert_return(
+  () => invoke($2, `as-i16x8_add-operands`, [
+    i16x8([0xffff, 0x4, 0x9, 0x10, 0x19, 0x24, 0x31, 0x40]),
+    1,
+    i16x8([0x40, 0x31, 0x24, 0x19, 0x10, 0x9, 0x4, 0xffff]),
+    1,
+  ]),
+  [i16x8([0x41, 0x35, 0x2d, 0x29, 0x29, 0x2d, 0x35, 0x41])],
+);
+
+// ./test/core/simd/simd_lane.wast:764
+assert_return(
+  () => invoke($2, `as-i32x4_add-operands`, [
+    i32x4([0xffffffff, 0x8, 0x1b, 0x40]),
+    1,
+    i32x4([0x40, 0x1b, 0x8, 0xffffffff]),
+    1,
+  ]),
+  [i32x4([0x41, 0x23, 0x23, 0x41])],
+);
+
+// ./test/core/simd/simd_lane.wast:766
+assert_return(
+  () => invoke($2, `as-i64x2_add-operands`, [
+    i64x2([0xffffffffffffffffn, 0x8n]),
+    1n,
+    i64x2([0x40n, 0x1bn]),
+    1n,
+  ]),
+  [i64x2([0x41n, 0x9n])],
+);
+
+// ./test/core/simd/simd_lane.wast:769
+assert_return(
+  () => invoke($2, `swizzle-as-i8x16_add-operands`, [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:775
+assert_return(
+  () => invoke($2, `shuffle-as-i8x16_sub-operands`, [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xf1, 0xf3, 0xf5, 0xf7, 0xf9, 0xfb, 0xfd, 0xff, 0x1, 0x3, 0x5, 0x7, 0x9, 0xb, 0xd, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:782
+assert_return(
+  () => invoke($2, `as-i8x16_any_true-operand`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    1,
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_lane.wast:783
+assert_return(
+  () => invoke($2, `as-i16x8_any_true-operand`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    1,
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_lane.wast:784
+assert_return(
+  () => invoke($2, `as-i32x4_any_true-operand1`, [i32x4([0x1, 0x0, 0x0, 0x0]), 0]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_lane.wast:785
+assert_return(
+  () => invoke($2, `as-i32x4_any_true-operand2`, [i64x2([0x1n, 0x0n]), 0n]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_lane.wast:787
+assert_return(
+  () => invoke($2, `swizzle-as-i8x16_all_true-operands`, [
+    i8x16([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_lane.wast:790
+assert_return(
+  () => invoke($2, `swizzle-as-i8x16_all_true-operands`, [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0x10]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_lane.wast:793
+assert_return(
+  () => invoke($2, `shuffle-as-i8x16_any_true-operands`, [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ]),
+  [value("i32", 1)],
+);
+
+// ./test/core/simd/simd_lane.wast:799
+let $3 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_lane.wast:821
+assert_return(
+  () => invoke($3, `as-v128_store-operand-1`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    1,
+  ]),
+  [
+    i8x16([0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:822
+assert_return(
+  () => invoke($3, `as-v128_store-operand-2`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    256,
+  ]),
+  [i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:823
+assert_return(
+  () => invoke($3, `as-v128_store-operand-3`, [i32x4([0x0, 0x0, 0x0, 0x0]), -1]),
+  [i32x4([0xffffffff, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:824
+assert_return(
+  () => invoke($3, `as-v128_store-operand-4`, [f32x4([0, 0, 0, 0]), value("f32", 3.14)]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.14),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:825
+assert_return(
+  () => invoke($3, `as-v128_store-operand-5`, [i64x2([0x0n, 0x0n]), -1n]),
+  [i64x2([0xffffffffffffffffn, 0x0n])],
+);
+
+// ./test/core/simd/simd_lane.wast:826
+assert_return(
+  () => invoke($3, `as-v128_store-operand-6`, [f64x2([0, 0]), value("f64", 3.14)]),
+  [new F64x2Pattern(value("f64", 3.14), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:830
+let $4 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_lane.wast:858
+assert_return(
+  () => invoke($4, `as-if-condition-value`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i32", 0)],
+);
+
+// ./test/core/simd/simd_lane.wast:859
+assert_return(
+  () => invoke($4, `as-return-value-1`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+    1,
+  ]),
+  [i16x8([0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_lane.wast:860
+assert_return(
+  () => invoke($4, `as-local_set-value`, [
+    i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff]),
+  ]),
+  [value("i32", -1)],
+);
+
+// ./test/core/simd/simd_lane.wast:861
+assert_return(
+  () => invoke($4, `as-global_set-value-1`, [f32x4([0, 0, 0, 0]), value("f32", 3.14)]),
+  [
+    new F32x4Pattern(
+      value("f32", 3.14),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:863
+assert_return(
+  () => invoke($4, `as-return-value-2`, [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]),
+  ]),
+  [
+    i8x16([0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:867
+assert_return(
+  () => invoke($4, `as-global_set-value-2`, [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]),
+    i8x16([0x10, 0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1]),
+  ]),
+  [
+    i8x16([0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_lane.wast:872
+assert_return(
+  () => invoke($4, `as-local_set-value-1`, [
+    i64x2([0xffffffffffffffffn, 0xffffffffffffffffn]),
+  ]),
+  [value("i64", -1n)],
+);
+
+// ./test/core/simd/simd_lane.wast:873
+assert_return(
+  () => invoke($4, `as-global_set-value-3`, [f64x2([0, 0]), value("f64", 3.14)]),
+  [new F64x2Pattern(value("f64", 3.14), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_lane.wast:877
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:878
+assert_malformed(
+  () => instantiate(`(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:879
+assert_malformed(
+  () => instantiate(`(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:880
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:881
+assert_malformed(
+  () => instantiate(`(func (result v128) (i16x8.replace_lane +0x7 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:882
+assert_malformed(
+  () => instantiate(`(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0) (i32.const 1))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:883
+assert_malformed(
+  () => instantiate(`(func (result v128) (f64x2.replace_lane +0x01 (v128.const f64x2 0 0) (f64.const 1.0))) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:887
+let $5 = instantiate(`(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))))`);
+
+// ./test/core/simd/simd_lane.wast:888
+let $6 = instantiate(`(module (func (result i32) (i16x8.extract_lane_s 0x07 (v128.const i16x8 0 0 0 0 0 0 0 0))))`);
+
+// ./test/core/simd/simd_lane.wast:889
+let $7 = instantiate(`(module (func (result i32) (i16x8.extract_lane_u 0x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0))))`);
+
+// ./test/core/simd/simd_lane.wast:890
+let $8 = instantiate(`(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0))))`);
+
+// ./test/core/simd/simd_lane.wast:891
+let $9 = instantiate(`(module (func (result f64) (f64x2.extract_lane 0x1 (v128.const f64x2 0 0))))`);
+
+// ./test/core/simd/simd_lane.wast:892
+let $10 = instantiate(`(module (func (result v128) (f32x4.replace_lane 0x3 (v128.const f32x4 0 0 0 0) (f32.const 1.0))))`);
+
+// ./test/core/simd/simd_lane.wast:893
+let $11 = instantiate(`(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0) (i64.const 1))))`);
+
+// ./test/core/simd/simd_lane.wast:897
+assert_malformed(
+  () => instantiate(`(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/core/simd/simd_lane.wast:901
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:909
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.extract_lane_s-2nd-arg-empty (result i32)
+      (i8x16.extract_lane_s 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:917
+assert_malformed(
+  () => instantiate(`(func $$i8x16.extract_lane_s-arg-empty (result i32)   (i8x16.extract_lane_s) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:925
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:933
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.extract_lane_u-2nd-arg-empty (result i32)
+      (i16x8.extract_lane_u 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:941
+assert_malformed(
+  () => instantiate(`(func $$i16x8.extract_lane_u-arg-empty (result i32)   (i16x8.extract_lane_u) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:949
+assert_malformed(
+  () => instantiate(`(func $$i32x4.extract_lane-1st-arg-empty (result i32)   (i32x4.extract_lane (v128.const i32x4 0 0 0 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:957
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.extract_lane-2nd-arg-empty (result i32)
+      (i32x4.extract_lane 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:965
+assert_malformed(
+  () => instantiate(`(func $$i32x4.extract_lane-arg-empty (result i32)   (i32x4.extract_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:973
+assert_malformed(
+  () => instantiate(`(func $$i64x2.extract_lane-1st-arg-empty (result i64)   (i64x2.extract_lane (v128.const i64x2 0 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:981
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.extract_lane-2nd-arg-empty (result i64)
+      (i64x2.extract_lane 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:989
+assert_malformed(
+  () => instantiate(`(func $$i64x2.extract_lane-arg-empty (result i64)   (i64x2.extract_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:997
+assert_malformed(
+  () => instantiate(`(func $$f32x4.extract_lane-1st-arg-empty (result f32)   (f32x4.extract_lane (v128.const f32x4 0 0 0 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1005
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.extract_lane-2nd-arg-empty (result f32)
+      (f32x4.extract_lane 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1013
+assert_malformed(
+  () => instantiate(`(func $$f32x4.extract_lane-arg-empty (result f32)   (f32x4.extract_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1021
+assert_malformed(
+  () => instantiate(`(func $$f64x2.extract_lane-1st-arg-empty (result f64)   (f64x2.extract_lane (v128.const f64x2 0 0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1029
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.extract_lane-2nd-arg-empty (result f64)
+      (f64x2.extract_lane 0)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1037
+assert_malformed(
+  () => instantiate(`(func $$f64x2.extract_lane-arg-empty (result f64)   (f64x2.extract_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1045
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1053
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.replace_lane-2nd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1061
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1069
+assert_malformed(
+  () => instantiate(`(func $$i8x16.replace_lane-arg-empty (result v128)   (i8x16.replace_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1077
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1085
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.replace_lane-2nd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1093
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1101
+assert_malformed(
+  () => instantiate(`(func $$i16x8.replace_lane-arg-empty (result v128)   (i16x8.replace_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1109
+assert_malformed(
+  () => instantiate(`(func $$i32x4.replace_lane-1st-arg-empty (result v128)   (i32x4.replace_lane (v128.const i32x4 0 0 0 0) (i32.const 1)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1117
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.replace_lane-2nd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1125
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.replace_lane-3rd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1133
+assert_malformed(
+  () => instantiate(`(func $$i32x4.replace_lane-arg-empty (result v128)   (i32x4.replace_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1141
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1149
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.replace_lane-2nd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (f32.const 1.0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1157
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.replace_lane-3rd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1165
+assert_malformed(
+  () => instantiate(`(func $$f32x4.replace_lane-arg-empty (result v128)   (f32x4.replace_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1173
+assert_malformed(
+  () => instantiate(`(func $$i64x2.replace_lane-1st-arg-empty (result v128)   (i64x2.replace_lane (v128.const i64x2 0 0) (i64.const 1)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1181
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.replace_lane-2nd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (i64.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1189
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.replace_lane-3rd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (v128.const i64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1197
+assert_malformed(
+  () => instantiate(`(func $$i64x2.replace_lane-arg-empty (result v128)   (i64x2.replace_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1205
+assert_malformed(
+  () => instantiate(`(func $$f64x2.replace_lane-1st-arg-empty (result v128)   (f64x2.replace_lane (v128.const f64x2 0 0) (f64.const 1.0)) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1213
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.replace_lane-2nd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (f64.const 1.0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1221
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.replace_lane-3rd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (v128.const f64x2 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_lane.wast:1229
+assert_malformed(
+  () => instantiate(`(func $$f64x2.replace_lane-arg-empty (result v128)   (f64x2.replace_lane) ) `),
+  `unexpected token`,
+);
+
+// ./test/core/simd/simd_lane.wast:1237
+assert_malformed(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1248
+assert_invalid(
+  () => instantiate(`(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`,
+);
+
+// ./test/core/simd/simd_lane.wast:1258
+assert_malformed(
+  () => instantiate(`(func $$i8x16.shuffle-arg-empty (result v128)   (i8x16.shuffle) ) `),
+  `invalid lane length`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js
new file mode 100644
index 0000000000..e609e1fe58
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load.wast.js
@@ -0,0 +1,295 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load.wast
+
+// ./test/core/simd/simd_load.wast:3
+let $0 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:11
+assert_return(
+  () => invoke($0, `v128.load`, []),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_load.wast:12
+assert_return(
+  () => invoke($0, `v128.load`, []),
+  [i16x8([0x100, 0x302, 0x504, 0x706, 0x908, 0xb0a, 0xd0c, 0xf0e])],
+);
+
+// ./test/core/simd/simd_load.wast:13
+assert_return(() => invoke($0, `v128.load`, []), [i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c])]);
+
+// ./test/core/simd/simd_load.wast:18
+let $1 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:24
+assert_return(() => invoke($1, `as-i8x16_extract_lane_s-value/0`, []), [value("i32", 0)]);
+
+// ./test/core/simd/simd_load.wast:26
+let $2 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:32
+assert_return(() => invoke($2, `as-i8x16.eq-operand`, []), [i32x4([0xffffffff, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load.wast:34
+let $3 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:43
+assert_return(
+  () => invoke($3, `as-v128.not-operand`, []),
+  [i32x4([0xfcfdfeff, 0xf8f9fafb, 0xf4f5f6f7, 0xf0f1f2f3])],
+);
+
+// ./test/core/simd/simd_load.wast:44
+assert_return(() => invoke($3, `as-i8x16.all_true-operand`, []), [value("i32", 0)]);
+
+// ./test/core/simd/simd_load.wast:46
+let $4 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:54
+assert_return(
+  () => invoke($4, `as-v128.bitselect-operand`, []),
+  [i32x4([0xabababab, 0xaaaaaaaa, 0xbbbbbbbb, 0xbbaabbaa])],
+);
+
+// ./test/core/simd/simd_load.wast:56
+let $5 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:62
+assert_return(
+  () => invoke($5, `as-i8x16.shl-operand`, []),
+  [i32x4([0x54545454, 0x54545454, 0x54545454, 0x54545454])],
+);
+
+// ./test/core/simd/simd_load.wast:64
+let $6 = instantiate(`(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))
+    )
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:76
+assert_return(() => invoke($6, `as-add/sub-operand`, []), [i32x4([0x2, 0x2, 0x2, 0x2])]);
+
+// ./test/core/simd/simd_load.wast:78
+let $7 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:85
+assert_return(
+  () => invoke($7, `as-f32x4.mul-operand`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 256),
+      value("f32", 2),
+      value("f32", 3.6),
+      value("f32", -2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_load.wast:87
+let $8 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:93
+assert_return(
+  () => invoke($8, `as-f32x4.abs-operand`, []),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_load.wast:95
+let $9 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:102
+assert_return(
+  () => invoke($9, `as-f32x4.min-operand`, []),
+  [i32x4([0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa])],
+);
+
+// ./test/core/simd/simd_load.wast:104
+let $10 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:110
+assert_return(
+  () => invoke($10, `as-i32x4.trunc_sat_f32x4_s-operand`, []),
+  [i32x4([0x80, 0x1, 0x1, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_load.wast:112
+let $11 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:118
+assert_return(
+  () => invoke($11, `as-f32x4.convert_i32x4_u-operand`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+      value("f32", 2),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_load.wast:120
+let $12 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:127
+assert_return(
+  () => invoke($12, `as-i8x16.swizzle-operand`, []),
+  [
+    i8x16([0x73, 0x72, 0x71, 0x70, 0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68, 0x67, 0x66, 0x65, 0x64]),
+  ],
+);
+
+// ./test/core/simd/simd_load.wast:129
+let $13 = instantiate(`(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))))
+  )
+)`);
+
+// ./test/core/simd/simd_load.wast:135
+assert_return(() => invoke($13, `as-br-value`, []), [i32x4([0x3020100, 0x7060504, 0xb0a0908, 0xf0e0d0c])]);
+
+// ./test/core/simd/simd_load.wast:140
+assert_malformed(
+  () => instantiate(`(memory 1) (func (local v128) (drop (v128.load8 (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load.wast:147
+assert_malformed(
+  () => instantiate(`(memory 1) (func (local v128) (drop (v128.load16 (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load.wast:154
+assert_malformed(
+  () => instantiate(`(memory 1) (func (local v128) (drop (v128.load32 (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load.wast:165
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load.wast:169
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load.wast:173
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (local v128) (v128.load (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load.wast:181
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (drop (v128.load (local.get 2)))))`),
+  `unknown local 2`,
+);
+
+// ./test/core/simd/simd_load.wast:185
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (drop (v128.load))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js
new file mode 100644
index 0000000000..7fe67adb0e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load16_lane.wast.js
@@ -0,0 +1,424 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load16_lane.wast
+
+// ./test/core/simd/simd_load16_lane.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_load16_lane.wast:105
+assert_return(
+  () => invoke($0, `v128.load16_lane_0`, [
+    0,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:108
+assert_return(
+  () => invoke($0, `v128.load16_lane_1`, [
+    1,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:111
+assert_return(
+  () => invoke($0, `v128.load16_lane_2`, [
+    2,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:114
+assert_return(
+  () => invoke($0, `v128.load16_lane_3`, [
+    3,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:117
+assert_return(
+  () => invoke($0, `v128.load16_lane_4`, [
+    4,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:120
+assert_return(
+  () => invoke($0, `v128.load16_lane_5`, [
+    5,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:123
+assert_return(
+  () => invoke($0, `v128.load16_lane_6`, [
+    6,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:126
+assert_return(
+  () => invoke($0, `v128.load16_lane_7`, [
+    7,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:129
+assert_return(
+  () => invoke($0, `v128.load16_lane_0_offset_0`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:131
+assert_return(
+  () => invoke($0, `v128.load16_lane_1_offset_1`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:133
+assert_return(
+  () => invoke($0, `v128.load16_lane_2_offset_2`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:135
+assert_return(
+  () => invoke($0, `v128.load16_lane_3_offset_3`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:137
+assert_return(
+  () => invoke($0, `v128.load16_lane_4_offset_4`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:139
+assert_return(
+  () => invoke($0, `v128.load16_lane_5_offset_5`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:141
+assert_return(
+  () => invoke($0, `v128.load16_lane_6_offset_6`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:143
+assert_return(
+  () => invoke($0, `v128.load16_lane_7_offset_7`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:145
+assert_return(
+  () => invoke($0, `v128.load16_lane_0_align_1`, [
+    0,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:148
+assert_return(
+  () => invoke($0, `v128.load16_lane_0_align_2`, [
+    0,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:151
+assert_return(
+  () => invoke($0, `v128.load16_lane_1_align_1`, [
+    1,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:154
+assert_return(
+  () => invoke($0, `v128.load16_lane_1_align_2`, [
+    1,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:157
+assert_return(
+  () => invoke($0, `v128.load16_lane_2_align_1`, [
+    2,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:160
+assert_return(
+  () => invoke($0, `v128.load16_lane_2_align_2`, [
+    2,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:163
+assert_return(
+  () => invoke($0, `v128.load16_lane_3_align_1`, [
+    3,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:166
+assert_return(
+  () => invoke($0, `v128.load16_lane_3_align_2`, [
+    3,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:169
+assert_return(
+  () => invoke($0, `v128.load16_lane_4_align_1`, [
+    4,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:172
+assert_return(
+  () => invoke($0, `v128.load16_lane_4_align_2`, [
+    4,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:175
+assert_return(
+  () => invoke($0, `v128.load16_lane_5_align_1`, [
+    5,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:178
+assert_return(
+  () => invoke($0, `v128.load16_lane_5_align_2`, [
+    5,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:181
+assert_return(
+  () => invoke($0, `v128.load16_lane_6_align_1`, [
+    6,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:184
+assert_return(
+  () => invoke($0, `v128.load16_lane_6_align_2`, [
+    6,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:187
+assert_return(
+  () => invoke($0, `v128.load16_lane_7_align_1`, [
+    7,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:190
+assert_return(
+  () => invoke($0, `v128.load16_lane_7_align_2`, [
+    7,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807])],
+);
+
+// ./test/core/simd/simd_load16_lane.wast:195
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load16_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load16_lane.wast:201
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load16_lane 8 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_load16_lane.wast:207
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js
new file mode 100644
index 0000000000..fb8deca36e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load32_lane.wast.js
@@ -0,0 +1,228 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load32_lane.wast
+
+// ./test/core/simd/simd_load32_lane.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_load32_lane.wast:69
+assert_return(
+  () => invoke($0, `v128.load32_lane_0`, [0, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x3020100, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:72
+assert_return(
+  () => invoke($0, `v128.load32_lane_1`, [1, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x4030201, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:75
+assert_return(
+  () => invoke($0, `v128.load32_lane_2`, [2, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x5040302, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:78
+assert_return(
+  () => invoke($0, `v128.load32_lane_3`, [3, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x6050403])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:81
+assert_return(
+  () => invoke($0, `v128.load32_lane_0_offset_0`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x3020100, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:83
+assert_return(
+  () => invoke($0, `v128.load32_lane_1_offset_1`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x4030201, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:85
+assert_return(
+  () => invoke($0, `v128.load32_lane_2_offset_2`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x5040302, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:87
+assert_return(
+  () => invoke($0, `v128.load32_lane_3_offset_3`, [i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x6050403])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:89
+assert_return(
+  () => invoke($0, `v128.load32_lane_0_align_1`, [0, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x3020100, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:92
+assert_return(
+  () => invoke($0, `v128.load32_lane_0_align_2`, [0, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x3020100, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:95
+assert_return(
+  () => invoke($0, `v128.load32_lane_0_align_4`, [0, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x3020100, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:98
+assert_return(
+  () => invoke($0, `v128.load32_lane_1_align_1`, [1, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x4030201, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:101
+assert_return(
+  () => invoke($0, `v128.load32_lane_1_align_2`, [1, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x4030201, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:104
+assert_return(
+  () => invoke($0, `v128.load32_lane_1_align_4`, [1, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x4030201, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:107
+assert_return(
+  () => invoke($0, `v128.load32_lane_2_align_1`, [2, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x5040302, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:110
+assert_return(
+  () => invoke($0, `v128.load32_lane_2_align_2`, [2, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x5040302, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:113
+assert_return(
+  () => invoke($0, `v128.load32_lane_2_align_4`, [2, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x5040302, 0x0])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:116
+assert_return(
+  () => invoke($0, `v128.load32_lane_3_align_1`, [3, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x6050403])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:119
+assert_return(
+  () => invoke($0, `v128.load32_lane_3_align_2`, [3, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x6050403])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:122
+assert_return(
+  () => invoke($0, `v128.load32_lane_3_align_4`, [3, i32x4([0x0, 0x0, 0x0, 0x0])]),
+  [i32x4([0x0, 0x0, 0x0, 0x6050403])],
+);
+
+// ./test/core/simd/simd_load32_lane.wast:127
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load32_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load32_lane.wast:133
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load32_lane 4 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_load32_lane.wast:139
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js
new file mode 100644
index 0000000000..ff71464896
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load64_lane.wast.js
@@ -0,0 +1,156 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load64_lane.wast
+
+// ./test/core/simd/simd_load64_lane.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_load64_lane.wast:45
+assert_return(
+  () => invoke($0, `v128.load64_lane_0`, [0, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x706050403020100n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:48
+assert_return(
+  () => invoke($0, `v128.load64_lane_1`, [1, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:51
+assert_return(
+  () => invoke($0, `v128.load64_lane_0_offset_0`, [i64x2([0x0n, 0x0n])]),
+  [i64x2([0x706050403020100n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:53
+assert_return(
+  () => invoke($0, `v128.load64_lane_1_offset_1`, [i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:55
+assert_return(
+  () => invoke($0, `v128.load64_lane_0_align_1`, [0, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x706050403020100n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:58
+assert_return(
+  () => invoke($0, `v128.load64_lane_0_align_2`, [0, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x706050403020100n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:61
+assert_return(
+  () => invoke($0, `v128.load64_lane_0_align_4`, [0, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x706050403020100n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:64
+assert_return(
+  () => invoke($0, `v128.load64_lane_0_align_8`, [0, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x706050403020100n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:67
+assert_return(
+  () => invoke($0, `v128.load64_lane_1_align_1`, [1, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:70
+assert_return(
+  () => invoke($0, `v128.load64_lane_1_align_2`, [1, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:73
+assert_return(
+  () => invoke($0, `v128.load64_lane_1_align_4`, [1, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:76
+assert_return(
+  () => invoke($0, `v128.load64_lane_1_align_8`, [1, i64x2([0x0n, 0x0n])]),
+  [i64x2([0x0n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load64_lane.wast:81
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load64_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load64_lane.wast:87
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load64_lane 2 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_load64_lane.wast:93
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js
new file mode 100644
index 0000000000..61e75fdef1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load8_lane.wast.js
@@ -0,0 +1,704 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load8_lane.wast
+
+// ./test/core/simd/simd_load8_lane.wast:4
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_load8_lane.wast:153
+assert_return(
+  () => invoke($0, `v128.load8_lane_0`, [
+    0,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:156
+assert_return(
+  () => invoke($0, `v128.load8_lane_1`, [
+    1,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:159
+assert_return(
+  () => invoke($0, `v128.load8_lane_2`, [
+    2,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:162
+assert_return(
+  () => invoke($0, `v128.load8_lane_3`, [
+    3,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:165
+assert_return(
+  () => invoke($0, `v128.load8_lane_4`, [
+    4,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:168
+assert_return(
+  () => invoke($0, `v128.load8_lane_5`, [
+    5,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:171
+assert_return(
+  () => invoke($0, `v128.load8_lane_6`, [
+    6,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:174
+assert_return(
+  () => invoke($0, `v128.load8_lane_7`, [
+    7,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:177
+assert_return(
+  () => invoke($0, `v128.load8_lane_8`, [
+    8,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:180
+assert_return(
+  () => invoke($0, `v128.load8_lane_9`, [
+    9,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:183
+assert_return(
+  () => invoke($0, `v128.load8_lane_10`, [
+    10,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:186
+assert_return(
+  () => invoke($0, `v128.load8_lane_11`, [
+    11,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:189
+assert_return(
+  () => invoke($0, `v128.load8_lane_12`, [
+    12,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:192
+assert_return(
+  () => invoke($0, `v128.load8_lane_13`, [
+    13,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:195
+assert_return(
+  () => invoke($0, `v128.load8_lane_14`, [
+    14,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:198
+assert_return(
+  () => invoke($0, `v128.load8_lane_15`, [
+    15,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:201
+assert_return(
+  () => invoke($0, `v128.load8_lane_0_offset_0`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:203
+assert_return(
+  () => invoke($0, `v128.load8_lane_1_offset_1`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:205
+assert_return(
+  () => invoke($0, `v128.load8_lane_2_offset_2`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:207
+assert_return(
+  () => invoke($0, `v128.load8_lane_3_offset_3`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:209
+assert_return(
+  () => invoke($0, `v128.load8_lane_4_offset_4`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:211
+assert_return(
+  () => invoke($0, `v128.load8_lane_5_offset_5`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:213
+assert_return(
+  () => invoke($0, `v128.load8_lane_6_offset_6`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:215
+assert_return(
+  () => invoke($0, `v128.load8_lane_7_offset_7`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:217
+assert_return(
+  () => invoke($0, `v128.load8_lane_8_offset_8`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:219
+assert_return(
+  () => invoke($0, `v128.load8_lane_9_offset_9`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:221
+assert_return(
+  () => invoke($0, `v128.load8_lane_10_offset_10`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:223
+assert_return(
+  () => invoke($0, `v128.load8_lane_11_offset_11`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:225
+assert_return(
+  () => invoke($0, `v128.load8_lane_12_offset_12`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:227
+assert_return(
+  () => invoke($0, `v128.load8_lane_13_offset_13`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:229
+assert_return(
+  () => invoke($0, `v128.load8_lane_14_offset_14`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:231
+assert_return(
+  () => invoke($0, `v128.load8_lane_15_offset_15`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:233
+assert_return(
+  () => invoke($0, `v128.load8_lane_0_align_1`, [
+    0,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:236
+assert_return(
+  () => invoke($0, `v128.load8_lane_1_align_1`, [
+    1,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:239
+assert_return(
+  () => invoke($0, `v128.load8_lane_2_align_1`, [
+    2,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:242
+assert_return(
+  () => invoke($0, `v128.load8_lane_3_align_1`, [
+    3,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:245
+assert_return(
+  () => invoke($0, `v128.load8_lane_4_align_1`, [
+    4,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:248
+assert_return(
+  () => invoke($0, `v128.load8_lane_5_align_1`, [
+    5,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:251
+assert_return(
+  () => invoke($0, `v128.load8_lane_6_align_1`, [
+    6,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:254
+assert_return(
+  () => invoke($0, `v128.load8_lane_7_align_1`, [
+    7,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:257
+assert_return(
+  () => invoke($0, `v128.load8_lane_8_align_1`, [
+    8,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:260
+assert_return(
+  () => invoke($0, `v128.load8_lane_9_align_1`, [
+    9,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:263
+assert_return(
+  () => invoke($0, `v128.load8_lane_10_align_1`, [
+    10,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:266
+assert_return(
+  () => invoke($0, `v128.load8_lane_11_align_1`, [
+    11,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:269
+assert_return(
+  () => invoke($0, `v128.load8_lane_12_align_1`, [
+    12,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:272
+assert_return(
+  () => invoke($0, `v128.load8_lane_13_align_1`, [
+    13,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:275
+assert_return(
+  () => invoke($0, `v128.load8_lane_14_align_1`, [
+    14,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:278
+assert_return(
+  () => invoke($0, `v128.load8_lane_15_align_1`, [
+    15,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_load8_lane.wast:283
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load8_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load8_lane.wast:289
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.load8_lane 16 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_load8_lane.wast:295
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js
new file mode 100644
index 0000000000..3ee50e0b23
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load_extend.wast.js
@@ -0,0 +1,726 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load_extend.wast
+
+// ./test/core/simd/simd_load_extend.wast:3
+let $0 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_load_extend.wast:163
+assert_return(
+  () => invoke($0, `v128.load8x8_s`, [0]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:164
+assert_return(
+  () => invoke($0, `v128.load8x8_u`, [0]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:165
+assert_return(() => invoke($0, `v128.load16x4_s`, [0]), [i32x4([0x100, 0x302, 0x504, 0x706])]);
+
+// ./test/core/simd/simd_load_extend.wast:166
+assert_return(() => invoke($0, `v128.load16x4_u`, [0]), [i32x4([0x100, 0x302, 0x504, 0x706])]);
+
+// ./test/core/simd/simd_load_extend.wast:167
+assert_return(() => invoke($0, `v128.load32x2_s`, [0]), [i64x2([0x3020100n, 0x7060504n])]);
+
+// ./test/core/simd/simd_load_extend.wast:168
+assert_return(() => invoke($0, `v128.load32x2_u`, [0]), [i64x2([0x3020100n, 0x7060504n])]);
+
+// ./test/core/simd/simd_load_extend.wast:169
+assert_return(
+  () => invoke($0, `v128.load8x8_s`, [10]),
+  [i16x8([0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0xff80, 0xff81])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:170
+assert_return(
+  () => invoke($0, `v128.load8x8_u`, [10]),
+  [i16x8([0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x80, 0x81])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:171
+assert_return(() => invoke($0, `v128.load16x4_s`, [10]), [i32x4([0xb0a, 0xd0c, 0xf0e, 0xffff8180])]);
+
+// ./test/core/simd/simd_load_extend.wast:172
+assert_return(() => invoke($0, `v128.load16x4_u`, [10]), [i32x4([0xb0a, 0xd0c, 0xf0e, 0x8180])]);
+
+// ./test/core/simd/simd_load_extend.wast:173
+assert_return(() => invoke($0, `v128.load32x2_s`, [10]), [i64x2([0xd0c0b0an, 0xffffffff81800f0en])]);
+
+// ./test/core/simd/simd_load_extend.wast:174
+assert_return(() => invoke($0, `v128.load32x2_u`, [10]), [i64x2([0xd0c0b0an, 0x81800f0en])]);
+
+// ./test/core/simd/simd_load_extend.wast:175
+assert_return(
+  () => invoke($0, `v128.load8x8_s`, [20]),
+  [i16x8([0xff84, 0xff85, 0xff86, 0xff87, 0xff88, 0xff89, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:176
+assert_return(
+  () => invoke($0, `v128.load8x8_u`, [20]),
+  [i16x8([0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:177
+assert_return(
+  () => invoke($0, `v128.load16x4_s`, [20]),
+  [i32x4([0xffff8584, 0xffff8786, 0xffff8988, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:178
+assert_return(() => invoke($0, `v128.load16x4_u`, [20]), [i32x4([0x8584, 0x8786, 0x8988, 0x0])]);
+
+// ./test/core/simd/simd_load_extend.wast:179
+assert_return(() => invoke($0, `v128.load32x2_s`, [20]), [i64x2([0xffffffff87868584n, 0x8988n])]);
+
+// ./test/core/simd/simd_load_extend.wast:180
+assert_return(() => invoke($0, `v128.load32x2_u`, [20]), [i64x2([0x87868584n, 0x8988n])]);
+
+// ./test/core/simd/simd_load_extend.wast:183
+assert_return(
+  () => invoke($0, `v128.load8x8_s_const0`, []),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:184
+assert_return(
+  () => invoke($0, `v128.load8x8_u_const8`, []),
+  [i16x8([0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:185
+assert_return(() => invoke($0, `v128.load16x4_s_const10`, []), [i32x4([0xb0a, 0xd0c, 0xf0e, 0xffff8180])]);
+
+// ./test/core/simd/simd_load_extend.wast:186
+assert_return(() => invoke($0, `v128.load16x4_u_const20`, []), [i32x4([0x8584, 0x8786, 0x8988, 0x0])]);
+
+// ./test/core/simd/simd_load_extend.wast:187
+assert_return(
+  () => invoke($0, `v128.load32x2_s_const65520`, []),
+  [i64x2([0xd0c0b0an, 0xffffffff81800f0en])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:188
+assert_return(() => invoke($0, `v128.load32x2_u_const65526`, []), [i64x2([0x83828180n, 0x87868584n])]);
+
+// ./test/core/simd/simd_load_extend.wast:192
+assert_return(
+  () => invoke($0, `v128.load8x8_s_offset0`, [0]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:193
+assert_return(
+  () => invoke($0, `v128.load8x8_s_align1`, [1]),
+  [i16x8([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:194
+assert_return(
+  () => invoke($0, `v128.load8x8_s_offset0_align1`, [2]),
+  [i16x8([0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:195
+assert_return(
+  () => invoke($0, `v128.load8x8_s_offset10_align4`, [3]),
+  [i16x8([0xd, 0xe, 0xf, 0xff80, 0xff81, 0xff82, 0xff83, 0xff84])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:196
+assert_return(
+  () => invoke($0, `v128.load8x8_s_offset20_align8`, [4]),
+  [i16x8([0xff88, 0xff89, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:197
+assert_return(
+  () => invoke($0, `v128.load8x8_u_offset0`, [0]),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:198
+assert_return(
+  () => invoke($0, `v128.load8x8_u_align1`, [1]),
+  [i16x8([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:199
+assert_return(
+  () => invoke($0, `v128.load8x8_u_offset0_align1`, [2]),
+  [i16x8([0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:200
+assert_return(
+  () => invoke($0, `v128.load8x8_u_offset10_align4`, [3]),
+  [i16x8([0xd, 0xe, 0xf, 0x80, 0x81, 0x82, 0x83, 0x84])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:201
+assert_return(
+  () => invoke($0, `v128.load8x8_u_offset20_align8`, [4]),
+  [i16x8([0x88, 0x89, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:203
+assert_return(() => invoke($0, `v128.load16x4_s_offset0`, [0]), [i32x4([0x100, 0x302, 0x504, 0x706])]);
+
+// ./test/core/simd/simd_load_extend.wast:204
+assert_return(() => invoke($0, `v128.load16x4_s_align1`, [1]), [i32x4([0x201, 0x403, 0x605, 0x807])]);
+
+// ./test/core/simd/simd_load_extend.wast:205
+assert_return(
+  () => invoke($0, `v128.load16x4_s_offset0_align1`, [2]),
+  [i32x4([0x302, 0x504, 0x706, 0x908])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:206
+assert_return(
+  () => invoke($0, `v128.load16x4_s_offset10_align4`, [3]),
+  [i32x4([0xe0d, 0xffff800f, 0xffff8281, 0xffff8483])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:207
+assert_return(
+  () => invoke($0, `v128.load16x4_s_offset20_align8`, [4]),
+  [i32x4([0xffff8988, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:208
+assert_return(() => invoke($0, `v128.load16x4_u_offset0`, [0]), [i32x4([0x100, 0x302, 0x504, 0x706])]);
+
+// ./test/core/simd/simd_load_extend.wast:209
+assert_return(() => invoke($0, `v128.load16x4_u_align1`, [1]), [i32x4([0x201, 0x403, 0x605, 0x807])]);
+
+// ./test/core/simd/simd_load_extend.wast:210
+assert_return(
+  () => invoke($0, `v128.load16x4_u_offset0_align1`, [2]),
+  [i32x4([0x302, 0x504, 0x706, 0x908])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:211
+assert_return(
+  () => invoke($0, `v128.load16x4_u_offset10_align4`, [3]),
+  [i32x4([0xe0d, 0x800f, 0x8281, 0x8483])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:212
+assert_return(
+  () => invoke($0, `v128.load16x4_u_offset20_align8`, [4]),
+  [i32x4([0x8988, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:214
+assert_return(() => invoke($0, `v128.load32x2_s_offset0`, [0]), [i64x2([0x3020100n, 0x7060504n])]);
+
+// ./test/core/simd/simd_load_extend.wast:215
+assert_return(() => invoke($0, `v128.load32x2_s_align1`, [1]), [i64x2([0x4030201n, 0x8070605n])]);
+
+// ./test/core/simd/simd_load_extend.wast:216
+assert_return(
+  () => invoke($0, `v128.load32x2_s_offset0_align1`, [2]),
+  [i64x2([0x5040302n, 0x9080706n])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:217
+assert_return(
+  () => invoke($0, `v128.load32x2_s_offset10_align4`, [3]),
+  [i64x2([0xffffffff800f0e0dn, 0xffffffff84838281n])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:218
+assert_return(() => invoke($0, `v128.load32x2_s_offset20_align8`, [4]), [i64x2([0x8988n, 0x0n])]);
+
+// ./test/core/simd/simd_load_extend.wast:219
+assert_return(() => invoke($0, `v128.load32x2_u_offset0`, [0]), [i64x2([0x3020100n, 0x7060504n])]);
+
+// ./test/core/simd/simd_load_extend.wast:220
+assert_return(() => invoke($0, `v128.load32x2_u_align1`, [1]), [i64x2([0x4030201n, 0x8070605n])]);
+
+// ./test/core/simd/simd_load_extend.wast:221
+assert_return(
+  () => invoke($0, `v128.load32x2_u_offset0_align1`, [2]),
+  [i64x2([0x5040302n, 0x9080706n])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:222
+assert_return(
+  () => invoke($0, `v128.load32x2_u_offset10_align4`, [3]),
+  [i64x2([0x800f0e0dn, 0x84838281n])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:223
+assert_return(() => invoke($0, `v128.load32x2_u_offset20_align8`, [4]), [i64x2([0x8988n, 0x0n])]);
+
+// ./test/core/simd/simd_load_extend.wast:226
+assert_trap(() => invoke($0, `v128.load8x8_s`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:227
+assert_trap(() => invoke($0, `v128.load8x8_u`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:228
+assert_trap(() => invoke($0, `v128.load16x4_s`, [65536]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:229
+assert_trap(() => invoke($0, `v128.load16x4_u`, [65536]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:230
+assert_trap(() => invoke($0, `v128.load32x2_s`, [65529]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:231
+assert_trap(() => invoke($0, `v128.load32x2_u`, [65529]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:233
+assert_trap(() => invoke($0, `v128.load8x8_s_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:234
+assert_trap(() => invoke($0, `v128.load8x8_u_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:235
+assert_trap(() => invoke($0, `v128.load16x4_s_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:236
+assert_trap(() => invoke($0, `v128.load16x4_u_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:237
+assert_trap(() => invoke($0, `v128.load32x2_s_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:238
+assert_trap(() => invoke($0, `v128.load32x2_u_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_extend.wast:241
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load8x8_s (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:242
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load8x8_u (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:243
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load16x4_s (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:244
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load16x4_u (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:245
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load32x2_s (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:246
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load32x2_u (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:250
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load8x8_s-arg-empty (result v128)
+      (v128.load8x8_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:258
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load8x8_u-arg-empty (result v128)
+      (v128.load8x8_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:266
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load16x4_s-arg-empty (result v128)
+      (v128.load16x4_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:274
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load16x4_u-arg-empty (result v128)
+      (v128.load16x4_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:282
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load32x2_s-arg-empty (result v128)
+      (v128.load32x2_s)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:290
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load32x2_u-arg-empty (result v128)
+      (v128.load32x2_u)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:301
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:302
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:303
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:304
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:305
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:306
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_extend.wast:309
+let $1 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load_extend.wast:367
+assert_return(
+  () => invoke($1, `v128.load8x8_s-in-block`, []),
+  [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:368
+assert_return(
+  () => invoke($1, `v128.load8x8_u-in-block`, []),
+  [i16x8([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:369
+assert_return(() => invoke($1, `v128.load16x4_s-in-block`, []), [i32x4([0x302, 0x504, 0x706, 0x908])]);
+
+// ./test/core/simd/simd_load_extend.wast:370
+assert_return(() => invoke($1, `v128.load16x4_u-in-block`, []), [i32x4([0x403, 0x605, 0x807, 0xa09])]);
+
+// ./test/core/simd/simd_load_extend.wast:371
+assert_return(() => invoke($1, `v128.load32x2_s-in-block`, []), [i64x2([0x7060504n, 0xb0a0908n])]);
+
+// ./test/core/simd/simd_load_extend.wast:372
+assert_return(() => invoke($1, `v128.load32x2_u-in-block`, []), [i64x2([0x8070605n, 0xc0b0a09n])]);
+
+// ./test/core/simd/simd_load_extend.wast:373
+assert_return(
+  () => invoke($1, `v128.load8x8_s-as-br-value`, []),
+  [i16x8([0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:374
+assert_return(
+  () => invoke($1, `v128.load8x8_u-as-br-value`, []),
+  [i16x8([0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:375
+assert_return(() => invoke($1, `v128.load16x4_s-as-br-value`, []), [i32x4([0x908, 0xb0a, 0xd0c, 0xf0e])]);
+
+// ./test/core/simd/simd_load_extend.wast:376
+assert_return(() => invoke($1, `v128.load16x4_u-as-br-value`, []), [i32x4([0xa09, 0xc0b, 0xe0d, 0x800f])]);
+
+// ./test/core/simd/simd_load_extend.wast:377
+assert_return(
+  () => invoke($1, `v128.load32x2_s-as-br-value`, []),
+  [i64x2([0xd0c0b0an, 0xffffffff81800f0en])],
+);
+
+// ./test/core/simd/simd_load_extend.wast:378
+assert_return(() => invoke($1, `v128.load32x2_u-as-br-value`, []), [i64x2([0xe0d0c0bn, 0x8281800fn])]);
+
+// ./test/core/simd/simd_load_extend.wast:379
+assert_return(() => invoke($1, `v128.load8x8_s-extract_lane_s-operand`, []), [value("i32", 12)]);
+
+// ./test/core/simd/simd_load_extend.wast:380
+assert_return(() => invoke($1, `v128.load8x8_u-extract_lane_s-operand`, []), [value("i32", 13)]);
+
+// ./test/core/simd/simd_load_extend.wast:381
+assert_return(() => invoke($1, `v128.load16x4_s-extract_lane_s-operand`, []), [value("i32", 14)]);
+
+// ./test/core/simd/simd_load_extend.wast:382
+assert_return(() => invoke($1, `v128.load16x4_u-extract_lane_s-operand`, []), [value("i32", 15)]);
+
+// ./test/core/simd/simd_load_extend.wast:383
+assert_return(() => invoke($1, `v128.load32x2_s-extract_lane_s-operand`, []), [value("i32", -128)]);
+
+// ./test/core/simd/simd_load_extend.wast:384
+assert_return(() => invoke($1, `v128.load32x2_u-extract_lane_s-operand`, []), [value("i32", -127)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js
new file mode 100644
index 0000000000..ee1ece3d20
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load_splat.wast.js
@@ -0,0 +1,750 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load_splat.wast
+
+// ./test/core/simd/simd_load_splat.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_load_splat.wast:43
+assert_return(
+  () => invoke($0, `v128.load8_splat`, [0]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:44
+assert_return(
+  () => invoke($0, `v128.load8_splat`, [1]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:45
+assert_return(
+  () => invoke($0, `v128.load8_splat`, [2]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:46
+assert_return(
+  () => invoke($0, `v128.load8_splat`, [3]),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:47
+assert_return(
+  () => invoke($0, `v128.load8_splat`, [65535]),
+  [
+    i8x16([0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:48
+assert_return(
+  () => invoke($0, `v128.load16_splat`, [4]),
+  [i16x8([0x504, 0x504, 0x504, 0x504, 0x504, 0x504, 0x504, 0x504])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:49
+assert_return(
+  () => invoke($0, `v128.load16_splat`, [5]),
+  [i16x8([0x605, 0x605, 0x605, 0x605, 0x605, 0x605, 0x605, 0x605])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:50
+assert_return(
+  () => invoke($0, `v128.load16_splat`, [6]),
+  [i16x8([0x706, 0x706, 0x706, 0x706, 0x706, 0x706, 0x706, 0x706])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:51
+assert_return(
+  () => invoke($0, `v128.load16_splat`, [7]),
+  [i16x8([0x807, 0x807, 0x807, 0x807, 0x807, 0x807, 0x807, 0x807])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:52
+assert_return(
+  () => invoke($0, `v128.load16_splat`, [65534]),
+  [i16x8([0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:53
+assert_return(
+  () => invoke($0, `v128.load32_splat`, [8]),
+  [i32x4([0xb0a0908, 0xb0a0908, 0xb0a0908, 0xb0a0908])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:54
+assert_return(
+  () => invoke($0, `v128.load32_splat`, [9]),
+  [i32x4([0xc0b0a09, 0xc0b0a09, 0xc0b0a09, 0xc0b0a09])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:55
+assert_return(
+  () => invoke($0, `v128.load32_splat`, [10]),
+  [i32x4([0xd0c0b0a, 0xd0c0b0a, 0xd0c0b0a, 0xd0c0b0a])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:56
+assert_return(
+  () => invoke($0, `v128.load32_splat`, [11]),
+  [i32x4([0xe0d0c0b, 0xe0d0c0b, 0xe0d0c0b, 0xe0d0c0b])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:57
+assert_return(
+  () => invoke($0, `v128.load32_splat`, [65532]),
+  [i32x4([0x1f1e1d1c, 0x1f1e1d1c, 0x1f1e1d1c, 0x1f1e1d1c])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:58
+assert_return(() => invoke($0, `v128.load64_splat`, [12]), [i64x2([0xf0e0d0cn, 0xf0e0d0cn])]);
+
+// ./test/core/simd/simd_load_splat.wast:59
+assert_return(() => invoke($0, `v128.load64_splat`, [13]), [i64x2([0xf0e0dn, 0xf0e0dn])]);
+
+// ./test/core/simd/simd_load_splat.wast:60
+assert_return(() => invoke($0, `v128.load64_splat`, [14]), [i64x2([0xf0en, 0xf0en])]);
+
+// ./test/core/simd/simd_load_splat.wast:61
+assert_return(() => invoke($0, `v128.load64_splat`, [15]), [i64x2([0xfn, 0xfn])]);
+
+// ./test/core/simd/simd_load_splat.wast:62
+assert_return(
+  () => invoke($0, `v128.load64_splat`, [65528]),
+  [i64x2([0x1f1e1d1c1b1a1918n, 0x1f1e1d1c1b1a1918n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:65
+assert_return(
+  () => invoke($0, `v8x16.offset0`, [0]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:66
+assert_return(
+  () => invoke($0, `v8x16.align1`, [0]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:67
+assert_return(
+  () => invoke($0, `v8x16.offset1_align1`, [0]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:68
+assert_return(
+  () => invoke($0, `v8x16.offset2_align1`, [0]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:69
+assert_return(
+  () => invoke($0, `v8x16.offset15_align1`, [0]),
+  [
+    i8x16([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:70
+assert_return(
+  () => invoke($0, `v8x16.offset0`, [1]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:71
+assert_return(
+  () => invoke($0, `v8x16.align1`, [1]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:72
+assert_return(
+  () => invoke($0, `v8x16.offset1_align1`, [1]),
+  [
+    i8x16([0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:73
+assert_return(
+  () => invoke($0, `v8x16.offset2_align1`, [1]),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:74
+assert_return(
+  () => invoke($0, `v8x16.offset15_align1`, [1]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:75
+assert_return(
+  () => invoke($0, `v8x16.offset0`, [65535]),
+  [
+    i8x16([0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:76
+assert_return(
+  () => invoke($0, `v8x16.align1`, [65535]),
+  [
+    i8x16([0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:78
+assert_return(
+  () => invoke($0, `v16x8.offset0`, [0]),
+  [i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:79
+assert_return(
+  () => invoke($0, `v16x8.align1`, [0]),
+  [i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:80
+assert_return(
+  () => invoke($0, `v16x8.offset1_align1`, [0]),
+  [i16x8([0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:81
+assert_return(
+  () => invoke($0, `v16x8.offset2_align1`, [0]),
+  [i16x8([0x302, 0x302, 0x302, 0x302, 0x302, 0x302, 0x302, 0x302])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:82
+assert_return(
+  () => invoke($0, `v16x8.offset15_align2`, [0]),
+  [i16x8([0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:83
+assert_return(
+  () => invoke($0, `v16x8.offset0`, [1]),
+  [i16x8([0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:84
+assert_return(
+  () => invoke($0, `v16x8.align1`, [1]),
+  [i16x8([0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:85
+assert_return(
+  () => invoke($0, `v16x8.offset1_align1`, [1]),
+  [i16x8([0x302, 0x302, 0x302, 0x302, 0x302, 0x302, 0x302, 0x302])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:86
+assert_return(
+  () => invoke($0, `v16x8.offset2_align1`, [1]),
+  [i16x8([0x403, 0x403, 0x403, 0x403, 0x403, 0x403, 0x403, 0x403])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:87
+assert_return(
+  () => invoke($0, `v16x8.offset15_align2`, [1]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:88
+assert_return(
+  () => invoke($0, `v16x8.offset0`, [65534]),
+  [i16x8([0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:89
+assert_return(
+  () => invoke($0, `v16x8.align1`, [65534]),
+  [i16x8([0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e, 0x1f1e])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:91
+assert_return(
+  () => invoke($0, `v32x4.offset0`, [0]),
+  [i32x4([0x3020100, 0x3020100, 0x3020100, 0x3020100])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:92
+assert_return(
+  () => invoke($0, `v32x4.align1`, [0]),
+  [i32x4([0x3020100, 0x3020100, 0x3020100, 0x3020100])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:93
+assert_return(
+  () => invoke($0, `v32x4.offset1_align1`, [0]),
+  [i32x4([0x4030201, 0x4030201, 0x4030201, 0x4030201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:94
+assert_return(
+  () => invoke($0, `v32x4.offset2_align2`, [0]),
+  [i32x4([0x5040302, 0x5040302, 0x5040302, 0x5040302])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:95
+assert_return(() => invoke($0, `v32x4.offset15_align4`, [0]), [i32x4([0xf, 0xf, 0xf, 0xf])]);
+
+// ./test/core/simd/simd_load_splat.wast:96
+assert_return(
+  () => invoke($0, `v32x4.offset0`, [1]),
+  [i32x4([0x4030201, 0x4030201, 0x4030201, 0x4030201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:97
+assert_return(
+  () => invoke($0, `v32x4.align1`, [1]),
+  [i32x4([0x4030201, 0x4030201, 0x4030201, 0x4030201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:98
+assert_return(
+  () => invoke($0, `v32x4.offset1_align1`, [1]),
+  [i32x4([0x5040302, 0x5040302, 0x5040302, 0x5040302])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:99
+assert_return(
+  () => invoke($0, `v32x4.offset2_align2`, [1]),
+  [i32x4([0x6050403, 0x6050403, 0x6050403, 0x6050403])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:100
+assert_return(() => invoke($0, `v32x4.offset15_align4`, [1]), [i32x4([0x0, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_splat.wast:101
+assert_return(
+  () => invoke($0, `v32x4.offset0`, [65532]),
+  [i32x4([0x1f1e1d1c, 0x1f1e1d1c, 0x1f1e1d1c, 0x1f1e1d1c])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:102
+assert_return(
+  () => invoke($0, `v32x4.align1`, [65532]),
+  [i32x4([0x1f1e1d1c, 0x1f1e1d1c, 0x1f1e1d1c, 0x1f1e1d1c])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:104
+assert_return(() => invoke($0, `v64x2.offset0`, [0]), [i64x2([0x706050403020100n, 0x706050403020100n])]);
+
+// ./test/core/simd/simd_load_splat.wast:105
+assert_return(() => invoke($0, `v64x2.align1`, [0]), [i64x2([0x706050403020100n, 0x706050403020100n])]);
+
+// ./test/core/simd/simd_load_splat.wast:106
+assert_return(
+  () => invoke($0, `v64x2.offset1_align2`, [0]),
+  [i64x2([0x807060504030201n, 0x807060504030201n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:107
+assert_return(
+  () => invoke($0, `v64x2.offset2_align4`, [0]),
+  [i64x2([0x908070605040302n, 0x908070605040302n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:108
+assert_return(() => invoke($0, `v64x2.offset15_align8`, [0]), [i64x2([0xfn, 0xfn])]);
+
+// ./test/core/simd/simd_load_splat.wast:109
+assert_return(() => invoke($0, `v64x2.offset0`, [1]), [i64x2([0x807060504030201n, 0x807060504030201n])]);
+
+// ./test/core/simd/simd_load_splat.wast:110
+assert_return(() => invoke($0, `v64x2.align1`, [1]), [i64x2([0x807060504030201n, 0x807060504030201n])]);
+
+// ./test/core/simd/simd_load_splat.wast:111
+assert_return(
+  () => invoke($0, `v64x2.offset1_align2`, [1]),
+  [i64x2([0x908070605040302n, 0x908070605040302n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:112
+assert_return(
+  () => invoke($0, `v64x2.offset2_align4`, [1]),
+  [i64x2([0xa09080706050403n, 0xa09080706050403n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:113
+assert_return(() => invoke($0, `v64x2.offset15_align8`, [1]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_load_splat.wast:114
+assert_return(
+  () => invoke($0, `v64x2.offset0`, [65528]),
+  [i64x2([0x1f1e1d1c1b1a1918n, 0x1f1e1d1c1b1a1918n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:115
+assert_return(
+  () => invoke($0, `v64x2.align1`, [65528]),
+  [i64x2([0x1f1e1d1c1b1a1918n, 0x1f1e1d1c1b1a1918n])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:119
+assert_trap(() => invoke($0, `v128.load8_splat`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:120
+assert_trap(() => invoke($0, `v128.load16_splat`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:121
+assert_trap(() => invoke($0, `v128.load32_splat`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:122
+assert_trap(() => invoke($0, `v128.load64_splat`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:123
+assert_trap(() => invoke($0, `v128.load8_splat`, [65536]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:124
+assert_trap(() => invoke($0, `v128.load16_splat`, [65535]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:125
+assert_trap(() => invoke($0, `v128.load32_splat`, [65533]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:126
+assert_trap(() => invoke($0, `v128.load64_splat`, [65529]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:128
+assert_trap(() => invoke($0, `v8x16.offset1_align1`, [65535]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:129
+assert_trap(() => invoke($0, `v8x16.offset2_align1`, [65535]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:130
+assert_trap(() => invoke($0, `v8x16.offset15_align1`, [65535]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:131
+assert_trap(() => invoke($0, `v16x8.offset1_align1`, [65534]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:132
+assert_trap(() => invoke($0, `v16x8.offset2_align1`, [65534]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:133
+assert_trap(() => invoke($0, `v16x8.offset15_align2`, [65534]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:134
+assert_trap(() => invoke($0, `v32x4.offset1_align1`, [65532]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:135
+assert_trap(() => invoke($0, `v32x4.offset2_align2`, [65532]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:136
+assert_trap(() => invoke($0, `v32x4.offset15_align4`, [65532]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:137
+assert_trap(() => invoke($0, `v64x2.offset1_align2`, [65528]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:138
+assert_trap(() => invoke($0, `v64x2.offset2_align4`, [65528]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:139
+assert_trap(() => invoke($0, `v64x2.offset15_align8`, [65528]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:141
+assert_trap(() => invoke($0, `v8x16.offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:142
+assert_trap(() => invoke($0, `v16x8.offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:143
+assert_trap(() => invoke($0, `v32x4.offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:144
+assert_trap(() => invoke($0, `v64x2.offset1_align2`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:146
+assert_trap(() => invoke($0, `v8x16.offset65536`, [0]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:147
+assert_trap(() => invoke($0, `v16x8.offset65535`, [0]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:148
+assert_trap(() => invoke($0, `v32x4.offset65533`, [0]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:149
+assert_trap(() => invoke($0, `v64x2.offset65529`, [0]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:150
+assert_trap(() => invoke($0, `v8x16.offset65536`, [1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:151
+assert_trap(() => invoke($0, `v16x8.offset65535`, [1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:152
+assert_trap(() => invoke($0, `v32x4.offset65533`, [1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:153
+assert_trap(() => invoke($0, `v64x2.offset65529`, [1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_splat.wast:158
+let $1 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load_splat.wast:198
+assert_return(
+  () => invoke($1, `v128.load8_splat-in-block`, []),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:199
+assert_return(
+  () => invoke($1, `v128.load16_splat-in-block`, []),
+  [i16x8([0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201, 0x201])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:200
+assert_return(
+  () => invoke($1, `v128.load32_splat-in-block`, []),
+  [i32x4([0x5040302, 0x5040302, 0x5040302, 0x5040302])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:201
+assert_return(() => invoke($1, `v128.load64_splat-in-block`, []), [i64x2([0xa09n, 0xa09n])]);
+
+// ./test/core/simd/simd_load_splat.wast:202
+assert_return(
+  () => invoke($1, `v128.load8_splat-as-br-value`, []),
+  [
+    i8x16([0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3]),
+  ],
+);
+
+// ./test/core/simd/simd_load_splat.wast:203
+assert_return(
+  () => invoke($1, `v128.load16_splat-as-br-value`, []),
+  [i16x8([0x504, 0x504, 0x504, 0x504, 0x504, 0x504, 0x504, 0x504])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:204
+assert_return(
+  () => invoke($1, `v128.load32_splat-as-br-value`, []),
+  [i32x4([0x8070605, 0x8070605, 0x8070605, 0x8070605])],
+);
+
+// ./test/core/simd/simd_load_splat.wast:205
+assert_return(() => invoke($1, `v128.load64_splat-as-br-value`, []), [i64x2([0xan, 0xan])]);
+
+// ./test/core/simd/simd_load_splat.wast:206
+assert_return(() => invoke($1, `v128.load8_splat-extract_lane_s-operand`, []), [value("i32", 6)]);
+
+// ./test/core/simd/simd_load_splat.wast:207
+assert_return(() => invoke($1, `v128.load16_splat-extract_lane_s-operand`, []), [value("i32", 7)]);
+
+// ./test/core/simd/simd_load_splat.wast:208
+assert_return(() => invoke($1, `v128.load32_splat-extract_lane_s-operand`, []), [value("i32", 8)]);
+
+// ./test/core/simd/simd_load_splat.wast:209
+assert_return(() => invoke($1, `v128.load64_splat-extract_lane_s-operand`, []), [value("i32", 0)]);
+
+// ./test/core/simd/simd_load_splat.wast:214
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load8_splat (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:215
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load16_splat (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:216
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load32_splat (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:217
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load64_splat (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:222
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i8x16.load_splat (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:223
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i16x8.load_splat (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:224
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i32x4.load_splat (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:225
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i64x2.load_splat (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:230
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load8_splat-arg-empty (result v128)
+      (v128.load8_splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:238
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load16_splat-arg-empty (result v128)
+      (v128.load16_splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:246
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load32_splat-arg-empty (result v128)
+      (v128.load32_splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_splat.wast:254
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load64_splat-arg-empty (result v128)
+      (v128.load64_splat)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js
new file mode 100644
index 0000000000..00f6573b37
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_load_zero.wast.js
@@ -0,0 +1,264 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_load_zero.wast
+
+// ./test/core/simd/simd_load_zero.wast:3
+let $0 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_load_zero.wast:62
+assert_return(() => invoke($0, `v128.load32_zero`, [0]), [i32x4([0x3020100, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:63
+assert_return(() => invoke($0, `v128.load64_zero`, [0]), [i64x2([0x706050403020100n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:64
+assert_return(() => invoke($0, `v128.load32_zero`, [10]), [i32x4([0xd0c0b0a, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:65
+assert_return(() => invoke($0, `v128.load64_zero`, [10]), [i64x2([0x81800f0e0d0c0b0an, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:66
+assert_return(() => invoke($0, `v128.load32_zero`, [20]), [i32x4([0x87868584, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:67
+assert_return(() => invoke($0, `v128.load64_zero`, [20]), [i64x2([0x898887868584n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:70
+assert_return(() => invoke($0, `v128.load32_zero_const0`, []), [i32x4([0x3020100, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:71
+assert_return(() => invoke($0, `v128.load64_zero_const8`, []), [i64x2([0xf0e0d0c0b0a0908n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:75
+assert_return(() => invoke($0, `v128.load32_zero_offset0`, [0]), [i32x4([0x3020100, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:76
+assert_return(() => invoke($0, `v128.load32_zero_align1`, [1]), [i32x4([0x4030201, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:77
+assert_return(
+  () => invoke($0, `v128.load32_zero_offset0_align1`, [2]),
+  [i32x4([0x5040302, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_zero.wast:78
+assert_return(
+  () => invoke($0, `v128.load32_zero_offset10_align4`, [3]),
+  [i32x4([0x800f0e0d, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_load_zero.wast:81
+assert_return(() => invoke($0, `v128.load64_zero_offset0`, [0]), [i64x2([0x706050403020100n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:82
+assert_return(() => invoke($0, `v128.load64_zero_align1`, [1]), [i64x2([0x807060504030201n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:83
+assert_return(
+  () => invoke($0, `v128.load64_zero_offset0_align1`, [2]),
+  [i64x2([0x908070605040302n, 0x0n])],
+);
+
+// ./test/core/simd/simd_load_zero.wast:84
+assert_return(
+  () => invoke($0, `v128.load64_zero_offset10_align4`, [3]),
+  [i64x2([0x84838281800f0e0dn, 0x0n])],
+);
+
+// ./test/core/simd/simd_load_zero.wast:85
+assert_return(() => invoke($0, `v128.load64_zero_offset20_align8`, [4]), [i64x2([0x8988n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:88
+assert_trap(() => invoke($0, `v128.load32_zero`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_zero.wast:89
+assert_trap(() => invoke($0, `v128.load64_zero`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_zero.wast:91
+assert_trap(() => invoke($0, `v128.load32_zero_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_zero.wast:92
+assert_trap(() => invoke($0, `v128.load64_zero_offset1_align1`, [-1]), `out of bounds memory access`);
+
+// ./test/core/simd/simd_load_zero.wast:95
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load32_zero (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:96
+assert_invalid(
+  () => instantiate(`(module (memory 0) (func (result v128) (v128.load64_zero (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:100
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load32_zero-arg-empty (result v128)
+      (v128.load32_zero)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:108
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.load64_zero-arg-empty (result v128)
+      (v128.load64_zero)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:119
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:120
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:121
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:122
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:123
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:124
+assert_malformed(
+  () => instantiate(`(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0)))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_load_zero.wast:127
+let $1 = instantiate(`(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)))
+  )
+)`);
+
+// ./test/core/simd/simd_load_zero.wast:149
+assert_return(() => invoke($1, `v128.load32_zero-in-block`, []), [i32x4([0x3020100, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:150
+assert_return(() => invoke($1, `v128.load64_zero-in-block`, []), [i64x2([0x807060504030201n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:151
+assert_return(() => invoke($1, `v128.load32_zero-as-br-value`, []), [i32x4([0x9080706, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_load_zero.wast:152
+assert_return(() => invoke($1, `v128.load64_zero-as-br-value`, []), [i64x2([0xe0d0c0b0a090807n, 0x0n])]);
+
+// ./test/core/simd/simd_load_zero.wast:153
+assert_return(() => invoke($1, `v128.load32_zero-extract_lane_s-operand`, []), [value("i32", 252579084)]);
+
+// ./test/core/simd/simd_load_zero.wast:154
+assert_return(
+  () => invoke($1, `v128.load64_zero-extract_lane_s-operand`, []),
+  [value("i64", -8898124946043105779n)],
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js
new file mode 100644
index 0000000000..466e9ea901
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_splat.wast.js
@@ -0,0 +1,1607 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_splat.wast
+
+// ./test/core/simd/simd_splat.wast:3
+let $0 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_splat.wast:12
+assert_return(
+  () => invoke($0, `i8x16.splat`, [0]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:13
+assert_return(
+  () => invoke($0, `i8x16.splat`, [5]),
+  [
+    i8x16([0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:14
+assert_return(
+  () => invoke($0, `i8x16.splat`, [-5]),
+  [
+    i8x16([0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:15
+assert_return(
+  () => invoke($0, `i8x16.splat`, [257]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:16
+assert_return(
+  () => invoke($0, `i8x16.splat`, [255]),
+  [
+    i8x16([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:17
+assert_return(
+  () => invoke($0, `i8x16.splat`, [-128]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:18
+assert_return(
+  () => invoke($0, `i8x16.splat`, [127]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:19
+assert_return(
+  () => invoke($0, `i8x16.splat`, [-129]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:20
+assert_return(
+  () => invoke($0, `i8x16.splat`, [128]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:21
+assert_return(
+  () => invoke($0, `i8x16.splat`, [65407]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:22
+assert_return(
+  () => invoke($0, `i8x16.splat`, [128]),
+  [
+    i8x16([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:23
+assert_return(
+  () => invoke($0, `i8x16.splat`, [171]),
+  [i32x4([0xabababab, 0xabababab, 0xabababab, 0xabababab])],
+);
+
+// ./test/core/simd/simd_splat.wast:25
+assert_return(() => invoke($0, `i16x8.splat`, [0]), [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_splat.wast:26
+assert_return(() => invoke($0, `i16x8.splat`, [5]), [i16x8([0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5])]);
+
+// ./test/core/simd/simd_splat.wast:27
+assert_return(
+  () => invoke($0, `i16x8.splat`, [-5]),
+  [i16x8([0xfffb, 0xfffb, 0xfffb, 0xfffb, 0xfffb, 0xfffb, 0xfffb, 0xfffb])],
+);
+
+// ./test/core/simd/simd_splat.wast:28
+assert_return(
+  () => invoke($0, `i16x8.splat`, [65537]),
+  [i16x8([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_splat.wast:29
+assert_return(
+  () => invoke($0, `i16x8.splat`, [65535]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:30
+assert_return(
+  () => invoke($0, `i16x8.splat`, [-32768]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_splat.wast:31
+assert_return(
+  () => invoke($0, `i16x8.splat`, [32767]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_splat.wast:32
+assert_return(
+  () => invoke($0, `i16x8.splat`, [-32769]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_splat.wast:33
+assert_return(
+  () => invoke($0, `i16x8.splat`, [32768]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_splat.wast:34
+assert_return(
+  () => invoke($0, `i16x8.splat`, [-32769]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_splat.wast:35
+assert_return(
+  () => invoke($0, `i16x8.splat`, [32768]),
+  [i16x8([0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000])],
+);
+
+// ./test/core/simd/simd_splat.wast:36
+assert_return(
+  () => invoke($0, `i16x8.splat`, [43981]),
+  [i32x4([0xabcdabcd, 0xabcdabcd, 0xabcdabcd, 0xabcdabcd])],
+);
+
+// ./test/core/simd/simd_splat.wast:37
+assert_return(
+  () => invoke($0, `i16x8.splat`, [12345]),
+  [i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039])],
+);
+
+// ./test/core/simd/simd_splat.wast:38
+assert_return(
+  () => invoke($0, `i16x8.splat`, [4660]),
+  [i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234])],
+);
+
+// ./test/core/simd/simd_splat.wast:40
+assert_return(() => invoke($0, `i32x4.splat`, [0]), [i32x4([0x0, 0x0, 0x0, 0x0])]);
+
+// ./test/core/simd/simd_splat.wast:41
+assert_return(() => invoke($0, `i32x4.splat`, [5]), [i32x4([0x5, 0x5, 0x5, 0x5])]);
+
+// ./test/core/simd/simd_splat.wast:42
+assert_return(
+  () => invoke($0, `i32x4.splat`, [-5]),
+  [i32x4([0xfffffffb, 0xfffffffb, 0xfffffffb, 0xfffffffb])],
+);
+
+// ./test/core/simd/simd_splat.wast:43
+assert_return(
+  () => invoke($0, `i32x4.splat`, [-1]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:44
+assert_return(
+  () => invoke($0, `i32x4.splat`, [-1]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:45
+assert_return(
+  () => invoke($0, `i32x4.splat`, [-2147483648]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_splat.wast:46
+assert_return(
+  () => invoke($0, `i32x4.splat`, [2147483647]),
+  [i32x4([0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:47
+assert_return(
+  () => invoke($0, `i32x4.splat`, [-2147483648]),
+  [i32x4([0x80000000, 0x80000000, 0x80000000, 0x80000000])],
+);
+
+// ./test/core/simd/simd_splat.wast:48
+assert_return(
+  () => invoke($0, `i32x4.splat`, [1234567890]),
+  [i32x4([0x499602d2, 0x499602d2, 0x499602d2, 0x499602d2])],
+);
+
+// ./test/core/simd/simd_splat.wast:49
+assert_return(
+  () => invoke($0, `i32x4.splat`, [305419896]),
+  [i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678])],
+);
+
+// ./test/core/simd/simd_splat.wast:51
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 0)]),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+      value("f32", 0),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:52
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 1.1)]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.1),
+      value("f32", 1.1),
+      value("f32", 1.1),
+      value("f32", 1.1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:53
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", -1.1)]),
+  [
+    new F32x4Pattern(
+      value("f32", -1.1),
+      value("f32", -1.1),
+      value("f32", -1.1),
+      value("f32", -1.1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:54
+assert_return(
+  () => invoke($0, `f32x4.splat`, [
+    value("f32", 100000000000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 100000000000000000000000000000000000000),
+      value("f32", 100000000000000000000000000000000000000),
+      value("f32", 100000000000000000000000000000000000000),
+      value("f32", 100000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:55
+assert_return(
+  () => invoke($0, `f32x4.splat`, [
+    value("f32", -100000000000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -100000000000000000000000000000000000000),
+      value("f32", -100000000000000000000000000000000000000),
+      value("f32", -100000000000000000000000000000000000000),
+      value("f32", -100000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:56
+assert_return(
+  () => invoke($0, `f32x4.splat`, [
+    value("f32", 340282350000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+      value("f32", 340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:57
+assert_return(
+  () => invoke($0, `f32x4.splat`, [
+    value("f32", -340282350000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+      value("f32", -340282350000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:58
+assert_return(
+  () => invoke($0, `f32x4.splat`, [
+    value("f32", 170141180000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 170141180000000000000000000000000000000),
+      value("f32", 170141180000000000000000000000000000000),
+      value("f32", 170141180000000000000000000000000000000),
+      value("f32", 170141180000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:59
+assert_return(
+  () => invoke($0, `f32x4.splat`, [
+    value("f32", -170141180000000000000000000000000000000),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", -170141180000000000000000000000000000000),
+      value("f32", -170141180000000000000000000000000000000),
+      value("f32", -170141180000000000000000000000000000000),
+      value("f32", -170141180000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:60
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", Infinity)]),
+  [
+    new F32x4Pattern(
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+      value("f32", Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:61
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", -Infinity)]),
+  [
+    new F32x4Pattern(
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+      value("f32", -Infinity),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:62
+assert_return(
+  () => invoke($0, `f32x4.splat`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+      bytes("f32", [0x0, 0x0, 0xc0, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:63
+assert_return(
+  () => invoke($0, `f32x4.splat`, [bytes("f32", [0x1, 0x0, 0x80, 0x7f])]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0x1, 0x0, 0x80, 0x7f]),
+      bytes("f32", [0x1, 0x0, 0x80, 0x7f]),
+      bytes("f32", [0x1, 0x0, 0x80, 0x7f]),
+      bytes("f32", [0x1, 0x0, 0x80, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:64
+assert_return(
+  () => invoke($0, `f32x4.splat`, [bytes("f32", [0xff, 0xff, 0xff, 0x7f])]),
+  [
+    new F32x4Pattern(
+      bytes("f32", [0xff, 0xff, 0xff, 0x7f]),
+      bytes("f32", [0xff, 0xff, 0xff, 0x7f]),
+      bytes("f32", [0xff, 0xff, 0xff, 0x7f]),
+      bytes("f32", [0xff, 0xff, 0xff, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:65
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 123456790)]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:66
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 123456790)]),
+  [
+    new F32x4Pattern(
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+      value("f32", 123456790),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:67
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 81985530000000000)]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:68
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 81985530000000000)]),
+  [
+    new F32x4Pattern(
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+      value("f32", 81985530000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:69
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 1234567900000000000000000000)]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:70
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 1234567900000000000000000000)]),
+  [
+    new F32x4Pattern(
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+      value("f32", 1234567900000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:71
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 42984030000000000000000)]),
+  [
+    new F32x4Pattern(
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+      value("f32", 42984030000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:72
+assert_return(
+  () => invoke($0, `f32x4.splat`, [value("f32", 156374990000)]),
+  [
+    new F32x4Pattern(
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+      value("f32", 156374990000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:74
+assert_return(() => invoke($0, `i64x2.splat`, [0n]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_splat.wast:75
+assert_return(() => invoke($0, `i64x2.splat`, [0n]), [i64x2([0x0n, 0x0n])]);
+
+// ./test/core/simd/simd_splat.wast:76
+assert_return(() => invoke($0, `i64x2.splat`, [1n]), [i64x2([0x1n, 0x1n])]);
+
+// ./test/core/simd/simd_splat.wast:77
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-1n]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_splat.wast:78
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-9223372036854775808n]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_splat.wast:79
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-9223372036854775808n]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_splat.wast:80
+assert_return(
+  () => invoke($0, `i64x2.splat`, [9223372036854775807n]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_splat.wast:81
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-1n]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_splat.wast:82
+assert_return(
+  () => invoke($0, `i64x2.splat`, [9223372036854775807n]),
+  [i64x2([0x7fffffffffffffffn, 0x7fffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_splat.wast:83
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-1n]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_splat.wast:84
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-9223372036854775808n]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_splat.wast:85
+assert_return(
+  () => invoke($0, `i64x2.splat`, [-9223372036854775808n]),
+  [i64x2([0x8000000000000000n, 0x8000000000000000n])],
+);
+
+// ./test/core/simd/simd_splat.wast:86
+assert_return(
+  () => invoke($0, `i64x2.splat`, [1234567890123456789n]),
+  [i64x2([0x112210f47de98115n, 0x112210f47de98115n])],
+);
+
+// ./test/core/simd/simd_splat.wast:87
+assert_return(
+  () => invoke($0, `i64x2.splat`, [1311768467294899695n]),
+  [i64x2([0x1234567890abcdefn, 0x1234567890abcdefn])],
+);
+
+// ./test/core/simd/simd_splat.wast:89
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 0)]),
+  [new F64x2Pattern(value("f64", 0), value("f64", 0))],
+);
+
+// ./test/core/simd/simd_splat.wast:90
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", -0)]),
+  [new F64x2Pattern(value("f64", -0), value("f64", -0))],
+);
+
+// ./test/core/simd/simd_splat.wast:91
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 1.1)]),
+  [new F64x2Pattern(value("f64", 1.1), value("f64", 1.1))],
+);
+
+// ./test/core/simd/simd_splat.wast:92
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", -1.1)]),
+  [new F64x2Pattern(value("f64", -1.1), value("f64", -1.1))],
+);
+
+// ./test/core/simd/simd_splat.wast:93
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:94
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:95
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:96
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+      value("f64", -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:97
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 0.5)]),
+  [new F64x2Pattern(value("f64", 0.5), value("f64", 0.5))],
+);
+
+// ./test/core/simd/simd_splat.wast:98
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", -0.5)]),
+  [new F64x2Pattern(value("f64", -0.5), value("f64", -0.5))],
+);
+
+// ./test/core/simd/simd_splat.wast:99
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 1)]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_splat.wast:100
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", -1)]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_splat.wast:101
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 6.283185307179586)]),
+  [
+    new F64x2Pattern(
+      value("f64", 6.283185307179586),
+      value("f64", 6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:102
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", -6.283185307179586)]),
+  [
+    new F64x2Pattern(
+      value("f64", -6.283185307179586),
+      value("f64", -6.283185307179586),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:103
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:104
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+  ]),
+  [
+    new F64x2Pattern(
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+      value("f64", -179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:105
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", Infinity)]),
+  [new F64x2Pattern(value("f64", Infinity), value("f64", Infinity))],
+);
+
+// ./test/core/simd/simd_splat.wast:106
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", -Infinity)]),
+  [new F64x2Pattern(value("f64", -Infinity), value("f64", -Infinity))],
+);
+
+// ./test/core/simd/simd_splat.wast:107
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:108
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:109
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0x7f]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:110
+assert_return(
+  () => invoke($0, `f64x2.splat`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+  ]),
+  [
+    new F64x2Pattern(
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+      bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xff]),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:111
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 123456789)]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_splat.wast:112
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 123456789)]),
+  [new F64x2Pattern(value("f64", 123456789), value("f64", 123456789))],
+);
+
+// ./test/core/simd/simd_splat.wast:113
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 1375488932539311400000000)]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:114
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 1375488932539311400000000)]),
+  [
+    new F64x2Pattern(
+      value("f64", 1375488932539311400000000),
+      value("f64", 1375488932539311400000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:115
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 1234567890000000000000000000)]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:116
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 1234567890000000000000000000)]),
+  [
+    new F64x2Pattern(
+      value("f64", 1234567890000000000000000000),
+      value("f64", 1234567890000000000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:117
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 721152341463170500000000000000)]),
+  [
+    new F64x2Pattern(
+      value("f64", 721152341463170500000000000000),
+      value("f64", 721152341463170500000000000000),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:118
+assert_return(
+  () => invoke($0, `f64x2.splat`, [value("f64", 2623536934927580700)]),
+  [
+    new F64x2Pattern(
+      value("f64", 2623536934927580700),
+      value("f64", 2623536934927580700),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:122
+assert_malformed(
+  () => instantiate(`(func (result v128) (v128.splat (i32.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_splat.wast:127
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i8x16.splat (i64.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:128
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i8x16.splat (f32.const 0.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:129
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i8x16.splat (f64.const 0.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:130
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i16x8.splat (i64.const 1)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:131
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i16x8.splat (f32.const 1.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:132
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i16x8.splat (f64.const 1.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:133
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i32x4.splat (i64.const 2)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:134
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i32x4.splat (f32.const 2.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:135
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i32x4.splat (f64.const 2.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:136
+assert_invalid(
+  () => instantiate(`(module (func (result v128) f32x4.splat (i32.const 4)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:137
+assert_invalid(
+  () => instantiate(`(module (func (result v128) f32x4.splat (i64.const 4)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:138
+assert_invalid(
+  () => instantiate(`(module (func (result v128) f32x4.splat (f64.const 4.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:139
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i64x2.splat (i32.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:140
+assert_invalid(
+  () => instantiate(`(module (func (result v128) i64x2.splat (f64.const 0.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:141
+assert_invalid(
+  () => instantiate(`(module (func (result v128) f64x2.splat (i32.const 0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:142
+assert_invalid(
+  () => instantiate(`(module (func (result v128) f64x2.splat (f32.const 0.0)))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:148
+let $1 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_splat.wast:166
+assert_return(
+  () => invoke($1, `as-v128_store-operand-1`, [1]),
+  [
+    i8x16([0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:167
+assert_return(
+  () => invoke($1, `as-v128_store-operand-2`, [256]),
+  [i16x8([0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100, 0x100])],
+);
+
+// ./test/core/simd/simd_splat.wast:168
+assert_return(
+  () => invoke($1, `as-v128_store-operand-3`, [-1]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:169
+assert_return(() => invoke($1, `as-v128_store-operand-4`, [1n]), [i64x2([0x1n, 0x1n])]);
+
+// ./test/core/simd/simd_splat.wast:170
+assert_return(
+  () => invoke($1, `as-v128_store-operand-5`, [value("f64", -1)]),
+  [new F64x2Pattern(value("f64", -1), value("f64", -1))],
+);
+
+// ./test/core/simd/simd_splat.wast:172
+let $2 = instantiate(`(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))))
+)`);
+
+// ./test/core/simd/simd_splat.wast:292
+assert_return(() => invoke($2, `as-i8x16_extract_lane_s-operand-first`, [42]), [value("i32", 42)]);
+
+// ./test/core/simd/simd_splat.wast:293
+assert_return(() => invoke($2, `as-i8x16_extract_lane_s-operand-last`, [-42]), [value("i32", -42)]);
+
+// ./test/core/simd/simd_splat.wast:294
+assert_return(
+  () => invoke($2, `as-i16x8_extract_lane_s-operand-first`, [-32769]),
+  [value("i32", 32767)],
+);
+
+// ./test/core/simd/simd_splat.wast:295
+assert_return(() => invoke($2, `as-i16x8_extract_lane_s-operand-last`, [32768]), [value("i32", -32768)]);
+
+// ./test/core/simd/simd_splat.wast:296
+assert_return(
+  () => invoke($2, `as-i32x4_extract_lane_s-operand-first`, [2147483647]),
+  [value("i32", 2147483647)],
+);
+
+// ./test/core/simd/simd_splat.wast:297
+assert_return(
+  () => invoke($2, `as-i32x4_extract_lane_s-operand-last`, [-2147483648]),
+  [value("i32", -2147483648)],
+);
+
+// ./test/core/simd/simd_splat.wast:298
+assert_return(
+  () => invoke($2, `as-f32x4_extract_lane_s-operand-first`, [value("f32", 1.5)]),
+  [value("f32", 1.5)],
+);
+
+// ./test/core/simd/simd_splat.wast:299
+assert_return(
+  () => invoke($2, `as-f32x4_extract_lane_s-operand-last`, [value("f32", -0.25)]),
+  [value("f32", -0.25)],
+);
+
+// ./test/core/simd/simd_splat.wast:300
+assert_return(
+  () => invoke($2, `as-v8x16_swizzle-operands`, [1, -1]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:301
+assert_return(() => invoke($2, `as-i64x2_extract_lane-operand-last`, [-42n]), [value("i64", -42n)]);
+
+// ./test/core/simd/simd_splat.wast:302
+assert_return(() => invoke($2, `as-i64x2_extract_lane-operand-first`, [42n]), [value("i64", 42n)]);
+
+// ./test/core/simd/simd_splat.wast:303
+assert_return(
+  () => invoke($2, `as-f64x2_extract_lane-operand-first`, [value("f64", 1.5)]),
+  [value("f64", 1.5)],
+);
+
+// ./test/core/simd/simd_splat.wast:304
+assert_return(
+  () => invoke($2, `as-f64x2_extract_lane-operand-last`, [value("f64", -1)]),
+  [value("f64", -1)],
+);
+
+// ./test/core/simd/simd_splat.wast:306
+assert_return(
+  () => invoke($2, `as-i8x16_add_sub-operands`, [3, 2, 1]),
+  [
+    i8x16([0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:307
+assert_return(
+  () => invoke($2, `as-i16x8_add_sub_mul-operands`, [257, 128, 16, 16]),
+  [i16x8([0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81])],
+);
+
+// ./test/core/simd/simd_splat.wast:308
+assert_return(
+  () => invoke($2, `as-i32x4_add_sub_mul-operands`, [65535, 65537, 256, 256]),
+  [i32x4([0x10000, 0x10000, 0x10000, 0x10000])],
+);
+
+// ./test/core/simd/simd_splat.wast:309
+assert_return(
+  () => invoke($2, `as-i64x2_add_sub_mul-operands`, [
+    2147483647n,
+    4294967297n,
+    65536n,
+    65536n,
+  ]),
+  [i64x2([0x80000000n, 0x80000000n])],
+);
+
+// ./test/core/simd/simd_splat.wast:310
+assert_return(
+  () => invoke($2, `as-f64x2_add_sub_mul-operands`, [
+    value("f64", 0.5),
+    value("f64", 0.75),
+    value("f64", 0.5),
+    value("f64", 0.5),
+  ]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_splat.wast:312
+assert_return(
+  () => invoke($2, `as-i8x16_add_sat_s-operands`, [127, 1]),
+  [
+    i8x16([0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:313
+assert_return(
+  () => invoke($2, `as-i16x8_add_sat_s-operands`, [32767, 1]),
+  [i16x8([0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff, 0x7fff])],
+);
+
+// ./test/core/simd/simd_splat.wast:314
+assert_return(
+  () => invoke($2, `as-i8x16_sub_sat_u-operands`, [127, 255]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:315
+assert_return(
+  () => invoke($2, `as-i16x8_sub_sat_u-operands`, [32767, 65535]),
+  [i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0])],
+);
+
+// ./test/core/simd/simd_splat.wast:317
+assert_return(
+  () => invoke($2, `as-i8x16_shr_s-operand`, [240, 3]),
+  [
+    i8x16([0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:318
+assert_return(
+  () => invoke($2, `as-i16x8_shr_s-operand`, [256, 4]),
+  [i16x8([0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10])],
+);
+
+// ./test/core/simd/simd_splat.wast:319
+assert_return(
+  () => invoke($2, `as-i32x4_shr_s-operand`, [-1, 16]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:321
+assert_return(
+  () => invoke($2, `as-v128_and-operands`, [17, 255]),
+  [
+    i8x16([0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:322
+assert_return(
+  () => invoke($2, `as-v128_or-operands`, [0, 65535]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:323
+assert_return(
+  () => invoke($2, `as-v128_xor-operands`, [-252645136, -1]),
+  [i32x4([0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f, 0xf0f0f0f])],
+);
+
+// ./test/core/simd/simd_splat.wast:325
+assert_return(() => invoke($2, `as-i8x16_all_true-operand`, [0]), [value("i32", 0)]);
+
+// ./test/core/simd/simd_splat.wast:326
+assert_return(() => invoke($2, `as-i16x8_all_true-operand`, [65535]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_splat.wast:327
+assert_return(() => invoke($2, `as-i32x4_all_true-operand1`, [-252645136]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_splat.wast:328
+assert_return(() => invoke($2, `as-i32x4_all_true-operand2`, [-1n]), [value("i32", 1)]);
+
+// ./test/core/simd/simd_splat.wast:330
+assert_return(
+  () => invoke($2, `as-i8x16_eq-operands`, [1, 2]),
+  [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:331
+assert_return(
+  () => invoke($2, `as-i16x8_eq-operands`, [-1, 65535]),
+  [i16x8([0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:332
+assert_return(
+  () => invoke($2, `as-i32x4_eq-operands1`, [-1, -1]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:333
+assert_return(
+  () => invoke($2, `as-f32x4_eq-operands`, [value("f32", 0), value("f32", -0)]),
+  [i32x4([0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff])],
+);
+
+// ./test/core/simd/simd_splat.wast:334
+assert_return(
+  () => invoke($2, `as-i32x4_eq-operands2`, [1n, 2n]),
+  [i64x2([0xffffffff00000000n, 0xffffffff00000000n])],
+);
+
+// ./test/core/simd/simd_splat.wast:335
+assert_return(
+  () => invoke($2, `as-f64x2_eq-operands`, [value("f64", 0), value("f64", -0)]),
+  [i64x2([0xffffffffffffffffn, 0xffffffffffffffffn])],
+);
+
+// ./test/core/simd/simd_splat.wast:337
+assert_return(
+  () => invoke($2, `as-f32x4_abs-operand`, [value("f32", -1.125)]),
+  [
+    new F32x4Pattern(
+      value("f32", 1.125),
+      value("f32", 1.125),
+      value("f32", 1.125),
+      value("f32", 1.125),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:338
+assert_return(
+  () => invoke($2, `as-f32x4_min-operands`, [
+    value("f32", 0.25),
+    value("f32", 0.00000000000000000000000000000000000001),
+  ]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.00000000000000000000000000000000000001),
+      value("f32", 0.00000000000000000000000000000000000001),
+      value("f32", 0.00000000000000000000000000000000000001),
+      value("f32", 0.00000000000000000000000000000000000001),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:339
+assert_return(
+  () => invoke($2, `as-f32x4_div-operands`, [value("f32", 1), value("f32", 8)]),
+  [
+    new F32x4Pattern(
+      value("f32", 0.125),
+      value("f32", 0.125),
+      value("f32", 0.125),
+      value("f32", 0.125),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:341
+assert_return(
+  () => invoke($2, `as-f32x4_convert_s_i32x4-operand`, [12345]),
+  [
+    new F32x4Pattern(
+      value("f32", 12345),
+      value("f32", 12345),
+      value("f32", 12345),
+      value("f32", 12345),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:342
+assert_return(
+  () => invoke($2, `as-i32x4_trunc_s_f32x4_sat-operand`, [value("f32", 1.1)]),
+  [i32x4([0x1, 0x1, 0x1, 0x1])],
+);
+
+// ./test/core/simd/simd_splat.wast:347
+let $3 = instantiate(`(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)))
+)`);
+
+// ./test/core/simd/simd_splat.wast:371
+assert_return(
+  () => invoke($3, `as-br-value1`, [171]),
+  [
+    i8x16([0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab]),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:372
+assert_return(
+  () => invoke($3, `as-return-value1`, [43981]),
+  [i16x8([0xabcd, 0xabcd, 0xabcd, 0xabcd, 0xabcd, 0xabcd, 0xabcd, 0xabcd])],
+);
+
+// ./test/core/simd/simd_splat.wast:373
+assert_return(
+  () => invoke($3, `as-local_set-value1`, [65536]),
+  [i32x4([0x10000, 0x10000, 0x10000, 0x10000])],
+);
+
+// ./test/core/simd/simd_splat.wast:374
+assert_return(
+  () => invoke($3, `as-global_set-value1`, [value("f32", 1)]),
+  [
+    new F32x4Pattern(
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+      value("f32", 1),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_splat.wast:375
+assert_return(() => invoke($3, `as-br-value2`, [43981n]), [i64x2([0xabcdn, 0xabcdn])]);
+
+// ./test/core/simd/simd_splat.wast:376
+assert_return(() => invoke($3, `as-return-value2`, [43981n]), [i64x2([0xabcdn, 0xabcdn])]);
+
+// ./test/core/simd/simd_splat.wast:377
+assert_return(() => invoke($3, `as-local_set-value2`, [65536n]), [i64x2([0x10000n, 0x10000n])]);
+
+// ./test/core/simd/simd_splat.wast:378
+assert_return(
+  () => invoke($3, `as-global_set-value2`, [value("f64", 1)]),
+  [new F64x2Pattern(value("f64", 1), value("f64", 1))],
+);
+
+// ./test/core/simd/simd_splat.wast:383
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i8x16.splat-arg-empty (result v128)
+      (i8x16.splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:391
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i16x8.splat-arg-empty (result v128)
+      (i16x8.splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:399
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i32x4.splat-arg-empty (result v128)
+      (i32x4.splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:407
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f32x4.splat-arg-empty (result v128)
+      (f32x4.splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:415
+assert_invalid(
+  () => instantiate(`(module
+    (func $$i64x2.splat-arg-empty (result v128)
+      (i64x2.splat)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_splat.wast:423
+assert_invalid(
+  () => instantiate(`(module
+    (func $$f64x2.splat-arg-empty (result v128)
+      (f64x2.splat)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js
new file mode 100644
index 0000000000..aaecc09ddd
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store.wast.js
@@ -0,0 +1,238 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_store.wast
+
+// ./test/core/simd/simd_store.wast:3
+let $0 = instantiate(`(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))
+  )
+)`);
+
+// ./test/core/simd/simd_store.wast:40
+assert_return(
+  () => invoke($0, `v128.store_i8x16`, []),
+  [
+    i8x16([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf]),
+  ],
+);
+
+// ./test/core/simd/simd_store.wast:41
+assert_return(() => invoke($0, `v128.store_i16x8`, []), [i16x8([0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7])]);
+
+// ./test/core/simd/simd_store.wast:42
+assert_return(
+  () => invoke($0, `v128.store_i16x8_2`, []),
+  [i16x8([0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039, 0x3039])],
+);
+
+// ./test/core/simd/simd_store.wast:43
+assert_return(
+  () => invoke($0, `v128.store_i16x8_3`, []),
+  [i16x8([0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234, 0x1234])],
+);
+
+// ./test/core/simd/simd_store.wast:44
+assert_return(() => invoke($0, `v128.store_i32x4`, []), [i32x4([0x0, 0x1, 0x2, 0x3])]);
+
+// ./test/core/simd/simd_store.wast:45
+assert_return(
+  () => invoke($0, `v128.store_i32x4_2`, []),
+  [i32x4([0x75bcd15, 0x75bcd15, 0x75bcd15, 0x75bcd15])],
+);
+
+// ./test/core/simd/simd_store.wast:46
+assert_return(
+  () => invoke($0, `v128.store_i32x4_3`, []),
+  [i32x4([0x12345678, 0x12345678, 0x12345678, 0x12345678])],
+);
+
+// ./test/core/simd/simd_store.wast:47
+assert_return(
+  () => invoke($0, `v128.store_f32x4`, []),
+  [
+    new F32x4Pattern(
+      value("f32", 0),
+      value("f32", 1),
+      value("f32", 2),
+      value("f32", 3),
+    ),
+  ],
+);
+
+// ./test/core/simd/simd_store.wast:52
+let $1 = instantiate(`(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))))
+  )
+)`);
+
+// ./test/core/simd/simd_store.wast:89
+assert_return(() => invoke($1, `as-block-value`, []), []);
+
+// ./test/core/simd/simd_store.wast:90
+assert_return(() => invoke($1, `as-loop-value`, []), []);
+
+// ./test/core/simd/simd_store.wast:91
+assert_return(() => invoke($1, `as-br-value`, []), []);
+
+// ./test/core/simd/simd_store.wast:92
+assert_return(() => invoke($1, `as-br_if-value`, []), []);
+
+// ./test/core/simd/simd_store.wast:93
+assert_return(() => invoke($1, `as-br_if-value-cond`, []), []);
+
+// ./test/core/simd/simd_store.wast:94
+assert_return(() => invoke($1, `as-br_table-value`, []), []);
+
+// ./test/core/simd/simd_store.wast:95
+assert_return(() => invoke($1, `as-return-value`, []), []);
+
+// ./test/core/simd/simd_store.wast:96
+assert_return(() => invoke($1, `as-if-then`, []), []);
+
+// ./test/core/simd/simd_store.wast:97
+assert_return(() => invoke($1, `as-if-else`, []), []);
+
+// ./test/core/simd/simd_store.wast:102
+assert_malformed(
+  () => instantiate(`(memory 1) (func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_store.wast:109
+assert_malformed(
+  () => instantiate(`(memory 1) (func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_store.wast:116
+assert_malformed(
+  () => instantiate(`(memory 1) (func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/simd/simd_store.wast:127
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store.wast:131
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store.wast:135
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store.wast:143
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store.wast:151
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store.wast:159
+assert_invalid(
+  () => instantiate(`(module (memory 0)
+    (func $$v128.store-arg-empty
+      (v128.store)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js
new file mode 100644
index 0000000000..50e1431390
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store16_lane.wast.js
@@ -0,0 +1,512 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_store16_lane.wast
+
+// ./test/core/simd/simd_store16_lane.wast:4
+let $0 = instantiate(`(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))
+)`);
+
+// ./test/core/simd/simd_store16_lane.wast:193
+assert_return(
+  () => invoke($0, `v128.store16_lane_0`, [
+    0,
+    i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 256n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:196
+assert_return(
+  () => invoke($0, `v128.store16_lane_1`, [
+    1,
+    i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 513n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:199
+assert_return(
+  () => invoke($0, `v128.store16_lane_2`, [
+    2,
+    i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 770n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:202
+assert_return(
+  () => invoke($0, `v128.store16_lane_3`, [
+    3,
+    i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1027n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:205
+assert_return(
+  () => invoke($0, `v128.store16_lane_4`, [
+    4,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1284n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:208
+assert_return(
+  () => invoke($0, `v128.store16_lane_5`, [
+    5,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0]),
+  ]),
+  [value("i64", 1541n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:211
+assert_return(
+  () => invoke($0, `v128.store16_lane_6`, [
+    6,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0]),
+  ]),
+  [value("i64", 1798n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:214
+assert_return(
+  () => invoke($0, `v128.store16_lane_7`, [
+    7,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807]),
+  ]),
+  [value("i64", 2055n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:217
+assert_return(
+  () => invoke($0, `v128.store16_lane_0_offset_0`, [
+    i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 256n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:219
+assert_return(
+  () => invoke($0, `v128.store16_lane_1_offset_1`, [
+    i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 513n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:221
+assert_return(
+  () => invoke($0, `v128.store16_lane_2_offset_2`, [
+    i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 770n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:223
+assert_return(
+  () => invoke($0, `v128.store16_lane_3_offset_3`, [
+    i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1027n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:225
+assert_return(
+  () => invoke($0, `v128.store16_lane_4_offset_4`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1284n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:227
+assert_return(
+  () => invoke($0, `v128.store16_lane_5_offset_5`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0]),
+  ]),
+  [value("i64", 1541n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:229
+assert_return(
+  () => invoke($0, `v128.store16_lane_6_offset_6`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0]),
+  ]),
+  [value("i64", 1798n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:231
+assert_return(
+  () => invoke($0, `v128.store16_lane_7_offset_7`, [
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807]),
+  ]),
+  [value("i64", 2055n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:233
+assert_return(
+  () => invoke($0, `v128.store16_lane_0_align_1`, [
+    0,
+    i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 256n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:236
+assert_return(
+  () => invoke($0, `v128.store16_lane_0_align_2`, [
+    0,
+    i16x8([0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 256n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:239
+assert_return(
+  () => invoke($0, `v128.store16_lane_1_align_1`, [
+    1,
+    i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 513n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:242
+assert_return(
+  () => invoke($0, `v128.store16_lane_1_align_2`, [
+    1,
+    i16x8([0x0, 0x201, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 513n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:245
+assert_return(
+  () => invoke($0, `v128.store16_lane_2_align_1`, [
+    2,
+    i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 770n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:248
+assert_return(
+  () => invoke($0, `v128.store16_lane_2_align_2`, [
+    2,
+    i16x8([0x0, 0x0, 0x302, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 770n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:251
+assert_return(
+  () => invoke($0, `v128.store16_lane_3_align_1`, [
+    3,
+    i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1027n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:254
+assert_return(
+  () => invoke($0, `v128.store16_lane_3_align_2`, [
+    3,
+    i16x8([0x0, 0x0, 0x0, 0x403, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1027n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:257
+assert_return(
+  () => invoke($0, `v128.store16_lane_4_align_1`, [
+    4,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1284n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:260
+assert_return(
+  () => invoke($0, `v128.store16_lane_4_align_2`, [
+    4,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x504, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1284n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:263
+assert_return(
+  () => invoke($0, `v128.store16_lane_5_align_1`, [
+    5,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0]),
+  ]),
+  [value("i64", 1541n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:266
+assert_return(
+  () => invoke($0, `v128.store16_lane_5_align_2`, [
+    5,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x605, 0x0, 0x0]),
+  ]),
+  [value("i64", 1541n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:269
+assert_return(
+  () => invoke($0, `v128.store16_lane_6_align_1`, [
+    6,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0]),
+  ]),
+  [value("i64", 1798n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:272
+assert_return(
+  () => invoke($0, `v128.store16_lane_6_align_2`, [
+    6,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x706, 0x0]),
+  ]),
+  [value("i64", 1798n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:275
+assert_return(
+  () => invoke($0, `v128.store16_lane_7_align_1`, [
+    7,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807]),
+  ]),
+  [value("i64", 2055n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:278
+assert_return(
+  () => invoke($0, `v128.store16_lane_7_align_2`, [
+    7,
+    i16x8([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x807]),
+  ]),
+  [value("i64", 2055n)],
+);
+
+// ./test/core/simd/simd_store16_lane.wast:283
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store16_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store16_lane.wast:289
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store16_lane 8 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_store16_lane.wast:295
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js
new file mode 100644
index 0000000000..3b2c57bed7
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store32_lane.wast.js
@@ -0,0 +1,320 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_store32_lane.wast
+
+// ./test/core/simd/simd_store32_lane.wast:4
+let $0 = instantiate(`(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))
+)`);
+
+// ./test/core/simd/simd_store32_lane.wast:125
+assert_return(
+  () => invoke($0, `v128.store32_lane_0`, [0, i32x4([0x3020100, 0x0, 0x0, 0x0])]),
+  [value("i64", 50462976n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:128
+assert_return(
+  () => invoke($0, `v128.store32_lane_1`, [1, i32x4([0x0, 0x4030201, 0x0, 0x0])]),
+  [value("i64", 67305985n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:131
+assert_return(
+  () => invoke($0, `v128.store32_lane_2`, [2, i32x4([0x0, 0x0, 0x5040302, 0x0])]),
+  [value("i64", 84148994n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:134
+assert_return(
+  () => invoke($0, `v128.store32_lane_3`, [3, i32x4([0x0, 0x0, 0x0, 0x6050403])]),
+  [value("i64", 100992003n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:137
+assert_return(
+  () => invoke($0, `v128.store32_lane_0_offset_0`, [i32x4([0x3020100, 0x0, 0x0, 0x0])]),
+  [value("i64", 50462976n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:139
+assert_return(
+  () => invoke($0, `v128.store32_lane_1_offset_1`, [i32x4([0x0, 0x4030201, 0x0, 0x0])]),
+  [value("i64", 67305985n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:141
+assert_return(
+  () => invoke($0, `v128.store32_lane_2_offset_2`, [i32x4([0x0, 0x0, 0x5040302, 0x0])]),
+  [value("i64", 84148994n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:143
+assert_return(
+  () => invoke($0, `v128.store32_lane_3_offset_3`, [i32x4([0x0, 0x0, 0x0, 0x6050403])]),
+  [value("i64", 100992003n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:145
+assert_return(
+  () => invoke($0, `v128.store32_lane_0_align_1`, [
+    0,
+    i32x4([0x3020100, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 50462976n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:148
+assert_return(
+  () => invoke($0, `v128.store32_lane_0_align_2`, [
+    0,
+    i32x4([0x3020100, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 50462976n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:151
+assert_return(
+  () => invoke($0, `v128.store32_lane_0_align_4`, [
+    0,
+    i32x4([0x3020100, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 50462976n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:154
+assert_return(
+  () => invoke($0, `v128.store32_lane_1_align_1`, [
+    1,
+    i32x4([0x0, 0x4030201, 0x0, 0x0]),
+  ]),
+  [value("i64", 67305985n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:157
+assert_return(
+  () => invoke($0, `v128.store32_lane_1_align_2`, [
+    1,
+    i32x4([0x0, 0x4030201, 0x0, 0x0]),
+  ]),
+  [value("i64", 67305985n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:160
+assert_return(
+  () => invoke($0, `v128.store32_lane_1_align_4`, [
+    1,
+    i32x4([0x0, 0x4030201, 0x0, 0x0]),
+  ]),
+  [value("i64", 67305985n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:163
+assert_return(
+  () => invoke($0, `v128.store32_lane_2_align_1`, [
+    2,
+    i32x4([0x0, 0x0, 0x5040302, 0x0]),
+  ]),
+  [value("i64", 84148994n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:166
+assert_return(
+  () => invoke($0, `v128.store32_lane_2_align_2`, [
+    2,
+    i32x4([0x0, 0x0, 0x5040302, 0x0]),
+  ]),
+  [value("i64", 84148994n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:169
+assert_return(
+  () => invoke($0, `v128.store32_lane_2_align_4`, [
+    2,
+    i32x4([0x0, 0x0, 0x5040302, 0x0]),
+  ]),
+  [value("i64", 84148994n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:172
+assert_return(
+  () => invoke($0, `v128.store32_lane_3_align_1`, [
+    3,
+    i32x4([0x0, 0x0, 0x0, 0x6050403]),
+  ]),
+  [value("i64", 100992003n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:175
+assert_return(
+  () => invoke($0, `v128.store32_lane_3_align_2`, [
+    3,
+    i32x4([0x0, 0x0, 0x0, 0x6050403]),
+  ]),
+  [value("i64", 100992003n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:178
+assert_return(
+  () => invoke($0, `v128.store32_lane_3_align_4`, [
+    3,
+    i32x4([0x0, 0x0, 0x0, 0x6050403]),
+  ]),
+  [value("i64", 100992003n)],
+);
+
+// ./test/core/simd/simd_store32_lane.wast:183
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store32_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store32_lane.wast:189
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store32_lane 4 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_store32_lane.wast:195
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js
new file mode 100644
index 0000000000..605a6444a8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store64_lane.wast.js
@@ -0,0 +1,214 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_store64_lane.wast
+
+// ./test/core/simd/simd_store64_lane.wast:4
+let $0 = instantiate(`(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))
+)`);
+
+// ./test/core/simd/simd_store64_lane.wast:79
+assert_return(
+  () => invoke($0, `v128.store64_lane_0`, [0, i64x2([0x706050403020100n, 0x0n])]),
+  [value("i64", 506097522914230528n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:82
+assert_return(
+  () => invoke($0, `v128.store64_lane_1`, [1, i64x2([0x0n, 0x807060504030201n])]),
+  [value("i64", 578437695752307201n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:85
+assert_return(
+  () => invoke($0, `v128.store64_lane_0_offset_0`, [i64x2([0x706050403020100n, 0x0n])]),
+  [value("i64", 506097522914230528n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:87
+assert_return(
+  () => invoke($0, `v128.store64_lane_1_offset_1`, [i64x2([0x0n, 0x807060504030201n])]),
+  [value("i64", 578437695752307201n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:89
+assert_return(
+  () => invoke($0, `v128.store64_lane_0_align_1`, [
+    0,
+    i64x2([0x706050403020100n, 0x0n]),
+  ]),
+  [value("i64", 506097522914230528n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:92
+assert_return(
+  () => invoke($0, `v128.store64_lane_0_align_2`, [
+    0,
+    i64x2([0x706050403020100n, 0x0n]),
+  ]),
+  [value("i64", 506097522914230528n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:95
+assert_return(
+  () => invoke($0, `v128.store64_lane_0_align_4`, [
+    0,
+    i64x2([0x706050403020100n, 0x0n]),
+  ]),
+  [value("i64", 506097522914230528n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:98
+assert_return(
+  () => invoke($0, `v128.store64_lane_0_align_8`, [
+    0,
+    i64x2([0x706050403020100n, 0x0n]),
+  ]),
+  [value("i64", 506097522914230528n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:101
+assert_return(
+  () => invoke($0, `v128.store64_lane_1_align_1`, [
+    1,
+    i64x2([0x0n, 0x807060504030201n]),
+  ]),
+  [value("i64", 578437695752307201n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:104
+assert_return(
+  () => invoke($0, `v128.store64_lane_1_align_2`, [
+    1,
+    i64x2([0x0n, 0x807060504030201n]),
+  ]),
+  [value("i64", 578437695752307201n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:107
+assert_return(
+  () => invoke($0, `v128.store64_lane_1_align_4`, [
+    1,
+    i64x2([0x0n, 0x807060504030201n]),
+  ]),
+  [value("i64", 578437695752307201n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:110
+assert_return(
+  () => invoke($0, `v128.store64_lane_1_align_8`, [
+    1,
+    i64x2([0x0n, 0x807060504030201n]),
+  ]),
+  [value("i64", 578437695752307201n)],
+);
+
+// ./test/core/simd/simd_store64_lane.wast:115
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store64_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store64_lane.wast:121
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store64_lane 2 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_store64_lane.wast:127
+assert_invalid(
+  () => instantiate(`(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`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js b/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js
new file mode 100644
index 0000000000..46d45d74c2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/simd_store8_lane.wast.js
@@ -0,0 +1,736 @@
+// |jit-test| skip-if: !wasmSimdEnabled()
+
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/simd/simd_store8_lane.wast
+
+// ./test/core/simd/simd_store8_lane.wast:4
+let $0 = instantiate(`(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))
+)`);
+
+// ./test/core/simd/simd_store8_lane.wast:281
+assert_return(
+  () => invoke($0, `v128.store8_lane_0`, [
+    0,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:284
+assert_return(
+  () => invoke($0, `v128.store8_lane_1`, [
+    1,
+    i8x16([0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:287
+assert_return(
+  () => invoke($0, `v128.store8_lane_2`, [
+    2,
+    i8x16([0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 2n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:290
+assert_return(
+  () => invoke($0, `v128.store8_lane_3`, [
+    3,
+    i8x16([0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 3n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:293
+assert_return(
+  () => invoke($0, `v128.store8_lane_4`, [
+    4,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 4n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:296
+assert_return(
+  () => invoke($0, `v128.store8_lane_5`, [
+    5,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 5n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:299
+assert_return(
+  () => invoke($0, `v128.store8_lane_6`, [
+    6,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 6n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:302
+assert_return(
+  () => invoke($0, `v128.store8_lane_7`, [
+    7,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 7n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:305
+assert_return(
+  () => invoke($0, `v128.store8_lane_8`, [
+    8,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 8n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:308
+assert_return(
+  () => invoke($0, `v128.store8_lane_9`, [
+    9,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 9n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:311
+assert_return(
+  () => invoke($0, `v128.store8_lane_10`, [
+    10,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 10n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:314
+assert_return(
+  () => invoke($0, `v128.store8_lane_11`, [
+    11,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 11n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:317
+assert_return(
+  () => invoke($0, `v128.store8_lane_12`, [
+    12,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 12n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:320
+assert_return(
+  () => invoke($0, `v128.store8_lane_13`, [
+    13,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0]),
+  ]),
+  [value("i64", 13n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:323
+assert_return(
+  () => invoke($0, `v128.store8_lane_14`, [
+    14,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0]),
+  ]),
+  [value("i64", 14n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:326
+assert_return(
+  () => invoke($0, `v128.store8_lane_15`, [
+    15,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf]),
+  ]),
+  [value("i64", 15n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:329
+assert_return(
+  () => invoke($0, `v128.store8_lane_0_offset_0`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:331
+assert_return(
+  () => invoke($0, `v128.store8_lane_1_offset_1`, [
+    i8x16([0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:333
+assert_return(
+  () => invoke($0, `v128.store8_lane_2_offset_2`, [
+    i8x16([0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 2n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:335
+assert_return(
+  () => invoke($0, `v128.store8_lane_3_offset_3`, [
+    i8x16([0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 3n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:337
+assert_return(
+  () => invoke($0, `v128.store8_lane_4_offset_4`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 4n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:339
+assert_return(
+  () => invoke($0, `v128.store8_lane_5_offset_5`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 5n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:341
+assert_return(
+  () => invoke($0, `v128.store8_lane_6_offset_6`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 6n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:343
+assert_return(
+  () => invoke($0, `v128.store8_lane_7_offset_7`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 7n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:345
+assert_return(
+  () => invoke($0, `v128.store8_lane_8_offset_8`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 8n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:347
+assert_return(
+  () => invoke($0, `v128.store8_lane_9_offset_9`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 9n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:349
+assert_return(
+  () => invoke($0, `v128.store8_lane_10_offset_10`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 10n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:351
+assert_return(
+  () => invoke($0, `v128.store8_lane_11_offset_11`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 11n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:353
+assert_return(
+  () => invoke($0, `v128.store8_lane_12_offset_12`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 12n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:355
+assert_return(
+  () => invoke($0, `v128.store8_lane_13_offset_13`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0]),
+  ]),
+  [value("i64", 13n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:357
+assert_return(
+  () => invoke($0, `v128.store8_lane_14_offset_14`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0]),
+  ]),
+  [value("i64", 14n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:359
+assert_return(
+  () => invoke($0, `v128.store8_lane_15_offset_15`, [
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf]),
+  ]),
+  [value("i64", 15n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:361
+assert_return(
+  () => invoke($0, `v128.store8_lane_0_align_1`, [
+    0,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 0n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:364
+assert_return(
+  () => invoke($0, `v128.store8_lane_1_align_1`, [
+    1,
+    i8x16([0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 1n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:367
+assert_return(
+  () => invoke($0, `v128.store8_lane_2_align_1`, [
+    2,
+    i8x16([0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 2n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:370
+assert_return(
+  () => invoke($0, `v128.store8_lane_3_align_1`, [
+    3,
+    i8x16([0x0, 0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 3n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:373
+assert_return(
+  () => invoke($0, `v128.store8_lane_4_align_1`, [
+    4,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 4n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:376
+assert_return(
+  () => invoke($0, `v128.store8_lane_5_align_1`, [
+    5,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 5n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:379
+assert_return(
+  () => invoke($0, `v128.store8_lane_6_align_1`, [
+    6,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 6n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:382
+assert_return(
+  () => invoke($0, `v128.store8_lane_7_align_1`, [
+    7,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 7n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:385
+assert_return(
+  () => invoke($0, `v128.store8_lane_8_align_1`, [
+    8,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 8n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:388
+assert_return(
+  () => invoke($0, `v128.store8_lane_9_align_1`, [
+    9,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 9n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:391
+assert_return(
+  () => invoke($0, `v128.store8_lane_10_align_1`, [
+    10,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 10n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:394
+assert_return(
+  () => invoke($0, `v128.store8_lane_11_align_1`, [
+    11,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xb, 0x0, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 11n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:397
+assert_return(
+  () => invoke($0, `v128.store8_lane_12_align_1`, [
+    12,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0, 0x0, 0x0]),
+  ]),
+  [value("i64", 12n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:400
+assert_return(
+  () => invoke($0, `v128.store8_lane_13_align_1`, [
+    13,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xd, 0x0, 0x0]),
+  ]),
+  [value("i64", 13n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:403
+assert_return(
+  () => invoke($0, `v128.store8_lane_14_align_1`, [
+    14,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe, 0x0]),
+  ]),
+  [value("i64", 14n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:406
+assert_return(
+  () => invoke($0, `v128.store8_lane_15_align_1`, [
+    15,
+    i8x16([0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf]),
+  ]),
+  [value("i64", 15n)],
+);
+
+// ./test/core/simd/simd_store8_lane.wast:411
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store8_lane 0 (local.get $$x) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/simd/simd_store8_lane.wast:417
+assert_invalid(
+  () => instantiate(`(module (memory 1)
+          (func (param $$x v128) (result v128)
+            (v128.store8_lane 16 (i32.const 0) (local.get $$x))))`),
+  `invalid lane index`,
+);
+
+// ./test/core/simd/simd_store8_lane.wast:423
+assert_invalid(
+  () => instantiate(`(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/js/src/jit-test/tests/wasm/spec/spec/skip-stack-guard-page.wast.js b/js/src/jit-test/tests/wasm/spec/spec/skip-stack-guard-page.wast.js
new file mode 100644
index 0000000000..ef1a036caf
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/skip-stack-guard-page.wast.js
@@ -0,0 +1,2320 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/skip-stack-guard-page.wast
+
+// ./test/core/skip-stack-guard-page.wast:2
+let $0 = instantiate(`(module
+  (memory 1)
+  (export "test-guard-page-skip" (func $$test-guard-page-skip))
+
+  (func $$test-guard-page-skip
+    (param $$depth i32)
+    (if (i32.eq (local.get $$depth) (i32.const 0))
+      (then (call $$function-with-many-locals))
+      (else (call $$test-guard-page-skip (i32.sub (local.get $$depth) (i32.const 1))))
+    )
+  )
+
+  (func $$function-with-many-locals
+
+    ;; 1056 i64 = 8448 bytes of locals
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x000-0x007
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x008-0x00f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x010-0x017
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x018-0x01f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x020-0x027
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x028-0x02f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x030-0x037
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x038-0x03f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x040-0x047
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x048-0x04f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x050-0x057
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x058-0x05f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x060-0x067
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x068-0x06f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x070-0x077
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x078-0x07f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x080-0x087
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x088-0x08f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x090-0x097
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x098-0x09f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a0-0x0a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a8-0x0af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b0-0x0b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b8-0x0bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c0-0x0c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c8-0x0cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d0-0x0d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d8-0x0df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e0-0x0e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e8-0x0ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f0-0x0f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f8-0x0ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x100-0x107
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x108-0x10f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x110-0x117
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x118-0x11f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x120-0x127
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x128-0x12f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x130-0x137
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x138-0x13f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x140-0x147
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x148-0x14f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x150-0x157
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x158-0x15f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x160-0x167
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x168-0x16f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x170-0x177
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x178-0x17f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x180-0x187
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x188-0x18f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x190-0x197
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x198-0x19f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a0-0x1a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a8-0x1af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b0-0x1b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b8-0x1bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c0-0x1c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c8-0x1cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d0-0x1d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d8-0x1df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e0-0x1e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e8-0x1ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f0-0x1f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f8-0x1ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x200-0x207
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x208-0x20f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x210-0x217
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x218-0x21f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x220-0x227
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x228-0x22f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x230-0x237
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x238-0x23f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x240-0x247
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x248-0x24f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x250-0x257
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x258-0x25f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x260-0x267
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x268-0x26f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x270-0x277
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x278-0x27f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x280-0x287
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x288-0x28f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x290-0x297
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x298-0x29f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a0-0x2a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a8-0x2af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b0-0x2b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b8-0x2bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c0-0x2c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c8-0x2cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d0-0x2d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d8-0x2df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e0-0x2e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e8-0x2ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f0-0x2f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f8-0x2ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x300-0x307
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x308-0x30f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x310-0x317
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x318-0x31f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x320-0x327
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x328-0x32f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x330-0x337
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x338-0x33f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x340-0x347
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x348-0x34f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x350-0x357
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x358-0x35f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x360-0x367
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x368-0x36f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x370-0x377
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x378-0x37f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x380-0x387
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x388-0x38f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x390-0x397
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x398-0x39f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a0-0x3a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a8-0x3af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b0-0x3b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b8-0x3bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c0-0x3c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c8-0x3cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d0-0x3d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d8-0x3df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e0-0x3e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e8-0x3ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f0-0x3f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f8-0x3ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x400-0x407
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x408-0x40f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x410-0x417
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x418-0x41f
+
+    ;; recurse first to try to make the callee access the stack below the space allocated for the locals before the locals themselves have been initialized.
+    (call $$function-with-many-locals)
+
+    ;; load from memory into the locals
+    (local.set 0x000 (i64.load offset=0x000 align=1 (i32.const 0)))
+    (local.set 0x001 (i64.load offset=0x001 align=1 (i32.const 0)))
+    (local.set 0x002 (i64.load offset=0x002 align=1 (i32.const 0)))
+    (local.set 0x003 (i64.load offset=0x003 align=1 (i32.const 0)))
+    (local.set 0x004 (i64.load offset=0x004 align=1 (i32.const 0)))
+    (local.set 0x005 (i64.load offset=0x005 align=1 (i32.const 0)))
+    (local.set 0x006 (i64.load offset=0x006 align=1 (i32.const 0)))
+    (local.set 0x007 (i64.load offset=0x007 align=1 (i32.const 0)))
+    (local.set 0x008 (i64.load offset=0x008 align=1 (i32.const 0)))
+    (local.set 0x009 (i64.load offset=0x009 align=1 (i32.const 0)))
+    (local.set 0x00a (i64.load offset=0x00a align=1 (i32.const 0)))
+    (local.set 0x00b (i64.load offset=0x00b align=1 (i32.const 0)))
+    (local.set 0x00c (i64.load offset=0x00c align=1 (i32.const 0)))
+    (local.set 0x00d (i64.load offset=0x00d align=1 (i32.const 0)))
+    (local.set 0x00e (i64.load offset=0x00e align=1 (i32.const 0)))
+    (local.set 0x00f (i64.load offset=0x00f align=1 (i32.const 0)))
+    (local.set 0x010 (i64.load offset=0x010 align=1 (i32.const 0)))
+    (local.set 0x011 (i64.load offset=0x011 align=1 (i32.const 0)))
+    (local.set 0x012 (i64.load offset=0x012 align=1 (i32.const 0)))
+    (local.set 0x013 (i64.load offset=0x013 align=1 (i32.const 0)))
+    (local.set 0x014 (i64.load offset=0x014 align=1 (i32.const 0)))
+    (local.set 0x015 (i64.load offset=0x015 align=1 (i32.const 0)))
+    (local.set 0x016 (i64.load offset=0x016 align=1 (i32.const 0)))
+    (local.set 0x017 (i64.load offset=0x017 align=1 (i32.const 0)))
+    (local.set 0x018 (i64.load offset=0x018 align=1 (i32.const 0)))
+    (local.set 0x019 (i64.load offset=0x019 align=1 (i32.const 0)))
+    (local.set 0x01a (i64.load offset=0x01a align=1 (i32.const 0)))
+    (local.set 0x01b (i64.load offset=0x01b align=1 (i32.const 0)))
+    (local.set 0x01c (i64.load offset=0x01c align=1 (i32.const 0)))
+    (local.set 0x01d (i64.load offset=0x01d align=1 (i32.const 0)))
+    (local.set 0x01e (i64.load offset=0x01e align=1 (i32.const 0)))
+    (local.set 0x01f (i64.load offset=0x01f align=1 (i32.const 0)))
+    (local.set 0x020 (i64.load offset=0x020 align=1 (i32.const 0)))
+    (local.set 0x021 (i64.load offset=0x021 align=1 (i32.const 0)))
+    (local.set 0x022 (i64.load offset=0x022 align=1 (i32.const 0)))
+    (local.set 0x023 (i64.load offset=0x023 align=1 (i32.const 0)))
+    (local.set 0x024 (i64.load offset=0x024 align=1 (i32.const 0)))
+    (local.set 0x025 (i64.load offset=0x025 align=1 (i32.const 0)))
+    (local.set 0x026 (i64.load offset=0x026 align=1 (i32.const 0)))
+    (local.set 0x027 (i64.load offset=0x027 align=1 (i32.const 0)))
+    (local.set 0x028 (i64.load offset=0x028 align=1 (i32.const 0)))
+    (local.set 0x029 (i64.load offset=0x029 align=1 (i32.const 0)))
+    (local.set 0x02a (i64.load offset=0x02a align=1 (i32.const 0)))
+    (local.set 0x02b (i64.load offset=0x02b align=1 (i32.const 0)))
+    (local.set 0x02c (i64.load offset=0x02c align=1 (i32.const 0)))
+    (local.set 0x02d (i64.load offset=0x02d align=1 (i32.const 0)))
+    (local.set 0x02e (i64.load offset=0x02e align=1 (i32.const 0)))
+    (local.set 0x02f (i64.load offset=0x02f align=1 (i32.const 0)))
+    (local.set 0x030 (i64.load offset=0x030 align=1 (i32.const 0)))
+    (local.set 0x031 (i64.load offset=0x031 align=1 (i32.const 0)))
+    (local.set 0x032 (i64.load offset=0x032 align=1 (i32.const 0)))
+    (local.set 0x033 (i64.load offset=0x033 align=1 (i32.const 0)))
+    (local.set 0x034 (i64.load offset=0x034 align=1 (i32.const 0)))
+    (local.set 0x035 (i64.load offset=0x035 align=1 (i32.const 0)))
+    (local.set 0x036 (i64.load offset=0x036 align=1 (i32.const 0)))
+    (local.set 0x037 (i64.load offset=0x037 align=1 (i32.const 0)))
+    (local.set 0x038 (i64.load offset=0x038 align=1 (i32.const 0)))
+    (local.set 0x039 (i64.load offset=0x039 align=1 (i32.const 0)))
+    (local.set 0x03a (i64.load offset=0x03a align=1 (i32.const 0)))
+    (local.set 0x03b (i64.load offset=0x03b align=1 (i32.const 0)))
+    (local.set 0x03c (i64.load offset=0x03c align=1 (i32.const 0)))
+    (local.set 0x03d (i64.load offset=0x03d align=1 (i32.const 0)))
+    (local.set 0x03e (i64.load offset=0x03e align=1 (i32.const 0)))
+    (local.set 0x03f (i64.load offset=0x03f align=1 (i32.const 0)))
+    (local.set 0x040 (i64.load offset=0x040 align=1 (i32.const 0)))
+    (local.set 0x041 (i64.load offset=0x041 align=1 (i32.const 0)))
+    (local.set 0x042 (i64.load offset=0x042 align=1 (i32.const 0)))
+    (local.set 0x043 (i64.load offset=0x043 align=1 (i32.const 0)))
+    (local.set 0x044 (i64.load offset=0x044 align=1 (i32.const 0)))
+    (local.set 0x045 (i64.load offset=0x045 align=1 (i32.const 0)))
+    (local.set 0x046 (i64.load offset=0x046 align=1 (i32.const 0)))
+    (local.set 0x047 (i64.load offset=0x047 align=1 (i32.const 0)))
+    (local.set 0x048 (i64.load offset=0x048 align=1 (i32.const 0)))
+    (local.set 0x049 (i64.load offset=0x049 align=1 (i32.const 0)))
+    (local.set 0x04a (i64.load offset=0x04a align=1 (i32.const 0)))
+    (local.set 0x04b (i64.load offset=0x04b align=1 (i32.const 0)))
+    (local.set 0x04c (i64.load offset=0x04c align=1 (i32.const 0)))
+    (local.set 0x04d (i64.load offset=0x04d align=1 (i32.const 0)))
+    (local.set 0x04e (i64.load offset=0x04e align=1 (i32.const 0)))
+    (local.set 0x04f (i64.load offset=0x04f align=1 (i32.const 0)))
+    (local.set 0x050 (i64.load offset=0x050 align=1 (i32.const 0)))
+    (local.set 0x051 (i64.load offset=0x051 align=1 (i32.const 0)))
+    (local.set 0x052 (i64.load offset=0x052 align=1 (i32.const 0)))
+    (local.set 0x053 (i64.load offset=0x053 align=1 (i32.const 0)))
+    (local.set 0x054 (i64.load offset=0x054 align=1 (i32.const 0)))
+    (local.set 0x055 (i64.load offset=0x055 align=1 (i32.const 0)))
+    (local.set 0x056 (i64.load offset=0x056 align=1 (i32.const 0)))
+    (local.set 0x057 (i64.load offset=0x057 align=1 (i32.const 0)))
+    (local.set 0x058 (i64.load offset=0x058 align=1 (i32.const 0)))
+    (local.set 0x059 (i64.load offset=0x059 align=1 (i32.const 0)))
+    (local.set 0x05a (i64.load offset=0x05a align=1 (i32.const 0)))
+    (local.set 0x05b (i64.load offset=0x05b align=1 (i32.const 0)))
+    (local.set 0x05c (i64.load offset=0x05c align=1 (i32.const 0)))
+    (local.set 0x05d (i64.load offset=0x05d align=1 (i32.const 0)))
+    (local.set 0x05e (i64.load offset=0x05e align=1 (i32.const 0)))
+    (local.set 0x05f (i64.load offset=0x05f align=1 (i32.const 0)))
+    (local.set 0x060 (i64.load offset=0x060 align=1 (i32.const 0)))
+    (local.set 0x061 (i64.load offset=0x061 align=1 (i32.const 0)))
+    (local.set 0x062 (i64.load offset=0x062 align=1 (i32.const 0)))
+    (local.set 0x063 (i64.load offset=0x063 align=1 (i32.const 0)))
+    (local.set 0x064 (i64.load offset=0x064 align=1 (i32.const 0)))
+    (local.set 0x065 (i64.load offset=0x065 align=1 (i32.const 0)))
+    (local.set 0x066 (i64.load offset=0x066 align=1 (i32.const 0)))
+    (local.set 0x067 (i64.load offset=0x067 align=1 (i32.const 0)))
+    (local.set 0x068 (i64.load offset=0x068 align=1 (i32.const 0)))
+    (local.set 0x069 (i64.load offset=0x069 align=1 (i32.const 0)))
+    (local.set 0x06a (i64.load offset=0x06a align=1 (i32.const 0)))
+    (local.set 0x06b (i64.load offset=0x06b align=1 (i32.const 0)))
+    (local.set 0x06c (i64.load offset=0x06c align=1 (i32.const 0)))
+    (local.set 0x06d (i64.load offset=0x06d align=1 (i32.const 0)))
+    (local.set 0x06e (i64.load offset=0x06e align=1 (i32.const 0)))
+    (local.set 0x06f (i64.load offset=0x06f align=1 (i32.const 0)))
+    (local.set 0x070 (i64.load offset=0x070 align=1 (i32.const 0)))
+    (local.set 0x071 (i64.load offset=0x071 align=1 (i32.const 0)))
+    (local.set 0x072 (i64.load offset=0x072 align=1 (i32.const 0)))
+    (local.set 0x073 (i64.load offset=0x073 align=1 (i32.const 0)))
+    (local.set 0x074 (i64.load offset=0x074 align=1 (i32.const 0)))
+    (local.set 0x075 (i64.load offset=0x075 align=1 (i32.const 0)))
+    (local.set 0x076 (i64.load offset=0x076 align=1 (i32.const 0)))
+    (local.set 0x077 (i64.load offset=0x077 align=1 (i32.const 0)))
+    (local.set 0x078 (i64.load offset=0x078 align=1 (i32.const 0)))
+    (local.set 0x079 (i64.load offset=0x079 align=1 (i32.const 0)))
+    (local.set 0x07a (i64.load offset=0x07a align=1 (i32.const 0)))
+    (local.set 0x07b (i64.load offset=0x07b align=1 (i32.const 0)))
+    (local.set 0x07c (i64.load offset=0x07c align=1 (i32.const 0)))
+    (local.set 0x07d (i64.load offset=0x07d align=1 (i32.const 0)))
+    (local.set 0x07e (i64.load offset=0x07e align=1 (i32.const 0)))
+    (local.set 0x07f (i64.load offset=0x07f align=1 (i32.const 0)))
+    (local.set 0x080 (i64.load offset=0x080 align=1 (i32.const 0)))
+    (local.set 0x081 (i64.load offset=0x081 align=1 (i32.const 0)))
+    (local.set 0x082 (i64.load offset=0x082 align=1 (i32.const 0)))
+    (local.set 0x083 (i64.load offset=0x083 align=1 (i32.const 0)))
+    (local.set 0x084 (i64.load offset=0x084 align=1 (i32.const 0)))
+    (local.set 0x085 (i64.load offset=0x085 align=1 (i32.const 0)))
+    (local.set 0x086 (i64.load offset=0x086 align=1 (i32.const 0)))
+    (local.set 0x087 (i64.load offset=0x087 align=1 (i32.const 0)))
+    (local.set 0x088 (i64.load offset=0x088 align=1 (i32.const 0)))
+    (local.set 0x089 (i64.load offset=0x089 align=1 (i32.const 0)))
+    (local.set 0x08a (i64.load offset=0x08a align=1 (i32.const 0)))
+    (local.set 0x08b (i64.load offset=0x08b align=1 (i32.const 0)))
+    (local.set 0x08c (i64.load offset=0x08c align=1 (i32.const 0)))
+    (local.set 0x08d (i64.load offset=0x08d align=1 (i32.const 0)))
+    (local.set 0x08e (i64.load offset=0x08e align=1 (i32.const 0)))
+    (local.set 0x08f (i64.load offset=0x08f align=1 (i32.const 0)))
+    (local.set 0x090 (i64.load offset=0x090 align=1 (i32.const 0)))
+    (local.set 0x091 (i64.load offset=0x091 align=1 (i32.const 0)))
+    (local.set 0x092 (i64.load offset=0x092 align=1 (i32.const 0)))
+    (local.set 0x093 (i64.load offset=0x093 align=1 (i32.const 0)))
+    (local.set 0x094 (i64.load offset=0x094 align=1 (i32.const 0)))
+    (local.set 0x095 (i64.load offset=0x095 align=1 (i32.const 0)))
+    (local.set 0x096 (i64.load offset=0x096 align=1 (i32.const 0)))
+    (local.set 0x097 (i64.load offset=0x097 align=1 (i32.const 0)))
+    (local.set 0x098 (i64.load offset=0x098 align=1 (i32.const 0)))
+    (local.set 0x099 (i64.load offset=0x099 align=1 (i32.const 0)))
+    (local.set 0x09a (i64.load offset=0x09a align=1 (i32.const 0)))
+    (local.set 0x09b (i64.load offset=0x09b align=1 (i32.const 0)))
+    (local.set 0x09c (i64.load offset=0x09c align=1 (i32.const 0)))
+    (local.set 0x09d (i64.load offset=0x09d align=1 (i32.const 0)))
+    (local.set 0x09e (i64.load offset=0x09e align=1 (i32.const 0)))
+    (local.set 0x09f (i64.load offset=0x09f align=1 (i32.const 0)))
+    (local.set 0x0a0 (i64.load offset=0x0a0 align=1 (i32.const 0)))
+    (local.set 0x0a1 (i64.load offset=0x0a1 align=1 (i32.const 0)))
+    (local.set 0x0a2 (i64.load offset=0x0a2 align=1 (i32.const 0)))
+    (local.set 0x0a3 (i64.load offset=0x0a3 align=1 (i32.const 0)))
+    (local.set 0x0a4 (i64.load offset=0x0a4 align=1 (i32.const 0)))
+    (local.set 0x0a5 (i64.load offset=0x0a5 align=1 (i32.const 0)))
+    (local.set 0x0a6 (i64.load offset=0x0a6 align=1 (i32.const 0)))
+    (local.set 0x0a7 (i64.load offset=0x0a7 align=1 (i32.const 0)))
+    (local.set 0x0a8 (i64.load offset=0x0a8 align=1 (i32.const 0)))
+    (local.set 0x0a9 (i64.load offset=0x0a9 align=1 (i32.const 0)))
+    (local.set 0x0aa (i64.load offset=0x0aa align=1 (i32.const 0)))
+    (local.set 0x0ab (i64.load offset=0x0ab align=1 (i32.const 0)))
+    (local.set 0x0ac (i64.load offset=0x0ac align=1 (i32.const 0)))
+    (local.set 0x0ad (i64.load offset=0x0ad align=1 (i32.const 0)))
+    (local.set 0x0ae (i64.load offset=0x0ae align=1 (i32.const 0)))
+    (local.set 0x0af (i64.load offset=0x0af align=1 (i32.const 0)))
+    (local.set 0x0b0 (i64.load offset=0x0b0 align=1 (i32.const 0)))
+    (local.set 0x0b1 (i64.load offset=0x0b1 align=1 (i32.const 0)))
+    (local.set 0x0b2 (i64.load offset=0x0b2 align=1 (i32.const 0)))
+    (local.set 0x0b3 (i64.load offset=0x0b3 align=1 (i32.const 0)))
+    (local.set 0x0b4 (i64.load offset=0x0b4 align=1 (i32.const 0)))
+    (local.set 0x0b5 (i64.load offset=0x0b5 align=1 (i32.const 0)))
+    (local.set 0x0b6 (i64.load offset=0x0b6 align=1 (i32.const 0)))
+    (local.set 0x0b7 (i64.load offset=0x0b7 align=1 (i32.const 0)))
+    (local.set 0x0b8 (i64.load offset=0x0b8 align=1 (i32.const 0)))
+    (local.set 0x0b9 (i64.load offset=0x0b9 align=1 (i32.const 0)))
+    (local.set 0x0ba (i64.load offset=0x0ba align=1 (i32.const 0)))
+    (local.set 0x0bb (i64.load offset=0x0bb align=1 (i32.const 0)))
+    (local.set 0x0bc (i64.load offset=0x0bc align=1 (i32.const 0)))
+    (local.set 0x0bd (i64.load offset=0x0bd align=1 (i32.const 0)))
+    (local.set 0x0be (i64.load offset=0x0be align=1 (i32.const 0)))
+    (local.set 0x0bf (i64.load offset=0x0bf align=1 (i32.const 0)))
+    (local.set 0x0c0 (i64.load offset=0x0c0 align=1 (i32.const 0)))
+    (local.set 0x0c1 (i64.load offset=0x0c1 align=1 (i32.const 0)))
+    (local.set 0x0c2 (i64.load offset=0x0c2 align=1 (i32.const 0)))
+    (local.set 0x0c3 (i64.load offset=0x0c3 align=1 (i32.const 0)))
+    (local.set 0x0c4 (i64.load offset=0x0c4 align=1 (i32.const 0)))
+    (local.set 0x0c5 (i64.load offset=0x0c5 align=1 (i32.const 0)))
+    (local.set 0x0c6 (i64.load offset=0x0c6 align=1 (i32.const 0)))
+    (local.set 0x0c7 (i64.load offset=0x0c7 align=1 (i32.const 0)))
+    (local.set 0x0c8 (i64.load offset=0x0c8 align=1 (i32.const 0)))
+    (local.set 0x0c9 (i64.load offset=0x0c9 align=1 (i32.const 0)))
+    (local.set 0x0ca (i64.load offset=0x0ca align=1 (i32.const 0)))
+    (local.set 0x0cb (i64.load offset=0x0cb align=1 (i32.const 0)))
+    (local.set 0x0cc (i64.load offset=0x0cc align=1 (i32.const 0)))
+    (local.set 0x0cd (i64.load offset=0x0cd align=1 (i32.const 0)))
+    (local.set 0x0ce (i64.load offset=0x0ce align=1 (i32.const 0)))
+    (local.set 0x0cf (i64.load offset=0x0cf align=1 (i32.const 0)))
+    (local.set 0x0d0 (i64.load offset=0x0d0 align=1 (i32.const 0)))
+    (local.set 0x0d1 (i64.load offset=0x0d1 align=1 (i32.const 0)))
+    (local.set 0x0d2 (i64.load offset=0x0d2 align=1 (i32.const 0)))
+    (local.set 0x0d3 (i64.load offset=0x0d3 align=1 (i32.const 0)))
+    (local.set 0x0d4 (i64.load offset=0x0d4 align=1 (i32.const 0)))
+    (local.set 0x0d5 (i64.load offset=0x0d5 align=1 (i32.const 0)))
+    (local.set 0x0d6 (i64.load offset=0x0d6 align=1 (i32.const 0)))
+    (local.set 0x0d7 (i64.load offset=0x0d7 align=1 (i32.const 0)))
+    (local.set 0x0d8 (i64.load offset=0x0d8 align=1 (i32.const 0)))
+    (local.set 0x0d9 (i64.load offset=0x0d9 align=1 (i32.const 0)))
+    (local.set 0x0da (i64.load offset=0x0da align=1 (i32.const 0)))
+    (local.set 0x0db (i64.load offset=0x0db align=1 (i32.const 0)))
+    (local.set 0x0dc (i64.load offset=0x0dc align=1 (i32.const 0)))
+    (local.set 0x0dd (i64.load offset=0x0dd align=1 (i32.const 0)))
+    (local.set 0x0de (i64.load offset=0x0de align=1 (i32.const 0)))
+    (local.set 0x0df (i64.load offset=0x0df align=1 (i32.const 0)))
+    (local.set 0x0e0 (i64.load offset=0x0e0 align=1 (i32.const 0)))
+    (local.set 0x0e1 (i64.load offset=0x0e1 align=1 (i32.const 0)))
+    (local.set 0x0e2 (i64.load offset=0x0e2 align=1 (i32.const 0)))
+    (local.set 0x0e3 (i64.load offset=0x0e3 align=1 (i32.const 0)))
+    (local.set 0x0e4 (i64.load offset=0x0e4 align=1 (i32.const 0)))
+    (local.set 0x0e5 (i64.load offset=0x0e5 align=1 (i32.const 0)))
+    (local.set 0x0e6 (i64.load offset=0x0e6 align=1 (i32.const 0)))
+    (local.set 0x0e7 (i64.load offset=0x0e7 align=1 (i32.const 0)))
+    (local.set 0x0e8 (i64.load offset=0x0e8 align=1 (i32.const 0)))
+    (local.set 0x0e9 (i64.load offset=0x0e9 align=1 (i32.const 0)))
+    (local.set 0x0ea (i64.load offset=0x0ea align=1 (i32.const 0)))
+    (local.set 0x0eb (i64.load offset=0x0eb align=1 (i32.const 0)))
+    (local.set 0x0ec (i64.load offset=0x0ec align=1 (i32.const 0)))
+    (local.set 0x0ed (i64.load offset=0x0ed align=1 (i32.const 0)))
+    (local.set 0x0ee (i64.load offset=0x0ee align=1 (i32.const 0)))
+    (local.set 0x0ef (i64.load offset=0x0ef align=1 (i32.const 0)))
+    (local.set 0x0f0 (i64.load offset=0x0f0 align=1 (i32.const 0)))
+    (local.set 0x0f1 (i64.load offset=0x0f1 align=1 (i32.const 0)))
+    (local.set 0x0f2 (i64.load offset=0x0f2 align=1 (i32.const 0)))
+    (local.set 0x0f3 (i64.load offset=0x0f3 align=1 (i32.const 0)))
+    (local.set 0x0f4 (i64.load offset=0x0f4 align=1 (i32.const 0)))
+    (local.set 0x0f5 (i64.load offset=0x0f5 align=1 (i32.const 0)))
+    (local.set 0x0f6 (i64.load offset=0x0f6 align=1 (i32.const 0)))
+    (local.set 0x0f7 (i64.load offset=0x0f7 align=1 (i32.const 0)))
+    (local.set 0x0f8 (i64.load offset=0x0f8 align=1 (i32.const 0)))
+    (local.set 0x0f9 (i64.load offset=0x0f9 align=1 (i32.const 0)))
+    (local.set 0x0fa (i64.load offset=0x0fa align=1 (i32.const 0)))
+    (local.set 0x0fb (i64.load offset=0x0fb align=1 (i32.const 0)))
+    (local.set 0x0fc (i64.load offset=0x0fc align=1 (i32.const 0)))
+    (local.set 0x0fd (i64.load offset=0x0fd align=1 (i32.const 0)))
+    (local.set 0x0fe (i64.load offset=0x0fe align=1 (i32.const 0)))
+    (local.set 0x0ff (i64.load offset=0x0ff align=1 (i32.const 0)))
+    (local.set 0x100 (i64.load offset=0x100 align=1 (i32.const 0)))
+    (local.set 0x101 (i64.load offset=0x101 align=1 (i32.const 0)))
+    (local.set 0x102 (i64.load offset=0x102 align=1 (i32.const 0)))
+    (local.set 0x103 (i64.load offset=0x103 align=1 (i32.const 0)))
+    (local.set 0x104 (i64.load offset=0x104 align=1 (i32.const 0)))
+    (local.set 0x105 (i64.load offset=0x105 align=1 (i32.const 0)))
+    (local.set 0x106 (i64.load offset=0x106 align=1 (i32.const 0)))
+    (local.set 0x107 (i64.load offset=0x107 align=1 (i32.const 0)))
+    (local.set 0x108 (i64.load offset=0x108 align=1 (i32.const 0)))
+    (local.set 0x109 (i64.load offset=0x109 align=1 (i32.const 0)))
+    (local.set 0x10a (i64.load offset=0x10a align=1 (i32.const 0)))
+    (local.set 0x10b (i64.load offset=0x10b align=1 (i32.const 0)))
+    (local.set 0x10c (i64.load offset=0x10c align=1 (i32.const 0)))
+    (local.set 0x10d (i64.load offset=0x10d align=1 (i32.const 0)))
+    (local.set 0x10e (i64.load offset=0x10e align=1 (i32.const 0)))
+    (local.set 0x10f (i64.load offset=0x10f align=1 (i32.const 0)))
+    (local.set 0x110 (i64.load offset=0x110 align=1 (i32.const 0)))
+    (local.set 0x111 (i64.load offset=0x111 align=1 (i32.const 0)))
+    (local.set 0x112 (i64.load offset=0x112 align=1 (i32.const 0)))
+    (local.set 0x113 (i64.load offset=0x113 align=1 (i32.const 0)))
+    (local.set 0x114 (i64.load offset=0x114 align=1 (i32.const 0)))
+    (local.set 0x115 (i64.load offset=0x115 align=1 (i32.const 0)))
+    (local.set 0x116 (i64.load offset=0x116 align=1 (i32.const 0)))
+    (local.set 0x117 (i64.load offset=0x117 align=1 (i32.const 0)))
+    (local.set 0x118 (i64.load offset=0x118 align=1 (i32.const 0)))
+    (local.set 0x119 (i64.load offset=0x119 align=1 (i32.const 0)))
+    (local.set 0x11a (i64.load offset=0x11a align=1 (i32.const 0)))
+    (local.set 0x11b (i64.load offset=0x11b align=1 (i32.const 0)))
+    (local.set 0x11c (i64.load offset=0x11c align=1 (i32.const 0)))
+    (local.set 0x11d (i64.load offset=0x11d align=1 (i32.const 0)))
+    (local.set 0x11e (i64.load offset=0x11e align=1 (i32.const 0)))
+    (local.set 0x11f (i64.load offset=0x11f align=1 (i32.const 0)))
+    (local.set 0x120 (i64.load offset=0x120 align=1 (i32.const 0)))
+    (local.set 0x121 (i64.load offset=0x121 align=1 (i32.const 0)))
+    (local.set 0x122 (i64.load offset=0x122 align=1 (i32.const 0)))
+    (local.set 0x123 (i64.load offset=0x123 align=1 (i32.const 0)))
+    (local.set 0x124 (i64.load offset=0x124 align=1 (i32.const 0)))
+    (local.set 0x125 (i64.load offset=0x125 align=1 (i32.const 0)))
+    (local.set 0x126 (i64.load offset=0x126 align=1 (i32.const 0)))
+    (local.set 0x127 (i64.load offset=0x127 align=1 (i32.const 0)))
+    (local.set 0x128 (i64.load offset=0x128 align=1 (i32.const 0)))
+    (local.set 0x129 (i64.load offset=0x129 align=1 (i32.const 0)))
+    (local.set 0x12a (i64.load offset=0x12a align=1 (i32.const 0)))
+    (local.set 0x12b (i64.load offset=0x12b align=1 (i32.const 0)))
+    (local.set 0x12c (i64.load offset=0x12c align=1 (i32.const 0)))
+    (local.set 0x12d (i64.load offset=0x12d align=1 (i32.const 0)))
+    (local.set 0x12e (i64.load offset=0x12e align=1 (i32.const 0)))
+    (local.set 0x12f (i64.load offset=0x12f align=1 (i32.const 0)))
+    (local.set 0x130 (i64.load offset=0x130 align=1 (i32.const 0)))
+    (local.set 0x131 (i64.load offset=0x131 align=1 (i32.const 0)))
+    (local.set 0x132 (i64.load offset=0x132 align=1 (i32.const 0)))
+    (local.set 0x133 (i64.load offset=0x133 align=1 (i32.const 0)))
+    (local.set 0x134 (i64.load offset=0x134 align=1 (i32.const 0)))
+    (local.set 0x135 (i64.load offset=0x135 align=1 (i32.const 0)))
+    (local.set 0x136 (i64.load offset=0x136 align=1 (i32.const 0)))
+    (local.set 0x137 (i64.load offset=0x137 align=1 (i32.const 0)))
+    (local.set 0x138 (i64.load offset=0x138 align=1 (i32.const 0)))
+    (local.set 0x139 (i64.load offset=0x139 align=1 (i32.const 0)))
+    (local.set 0x13a (i64.load offset=0x13a align=1 (i32.const 0)))
+    (local.set 0x13b (i64.load offset=0x13b align=1 (i32.const 0)))
+    (local.set 0x13c (i64.load offset=0x13c align=1 (i32.const 0)))
+    (local.set 0x13d (i64.load offset=0x13d align=1 (i32.const 0)))
+    (local.set 0x13e (i64.load offset=0x13e align=1 (i32.const 0)))
+    (local.set 0x13f (i64.load offset=0x13f align=1 (i32.const 0)))
+    (local.set 0x140 (i64.load offset=0x140 align=1 (i32.const 0)))
+    (local.set 0x141 (i64.load offset=0x141 align=1 (i32.const 0)))
+    (local.set 0x142 (i64.load offset=0x142 align=1 (i32.const 0)))
+    (local.set 0x143 (i64.load offset=0x143 align=1 (i32.const 0)))
+    (local.set 0x144 (i64.load offset=0x144 align=1 (i32.const 0)))
+    (local.set 0x145 (i64.load offset=0x145 align=1 (i32.const 0)))
+    (local.set 0x146 (i64.load offset=0x146 align=1 (i32.const 0)))
+    (local.set 0x147 (i64.load offset=0x147 align=1 (i32.const 0)))
+    (local.set 0x148 (i64.load offset=0x148 align=1 (i32.const 0)))
+    (local.set 0x149 (i64.load offset=0x149 align=1 (i32.const 0)))
+    (local.set 0x14a (i64.load offset=0x14a align=1 (i32.const 0)))
+    (local.set 0x14b (i64.load offset=0x14b align=1 (i32.const 0)))
+    (local.set 0x14c (i64.load offset=0x14c align=1 (i32.const 0)))
+    (local.set 0x14d (i64.load offset=0x14d align=1 (i32.const 0)))
+    (local.set 0x14e (i64.load offset=0x14e align=1 (i32.const 0)))
+    (local.set 0x14f (i64.load offset=0x14f align=1 (i32.const 0)))
+    (local.set 0x150 (i64.load offset=0x150 align=1 (i32.const 0)))
+    (local.set 0x151 (i64.load offset=0x151 align=1 (i32.const 0)))
+    (local.set 0x152 (i64.load offset=0x152 align=1 (i32.const 0)))
+    (local.set 0x153 (i64.load offset=0x153 align=1 (i32.const 0)))
+    (local.set 0x154 (i64.load offset=0x154 align=1 (i32.const 0)))
+    (local.set 0x155 (i64.load offset=0x155 align=1 (i32.const 0)))
+    (local.set 0x156 (i64.load offset=0x156 align=1 (i32.const 0)))
+    (local.set 0x157 (i64.load offset=0x157 align=1 (i32.const 0)))
+    (local.set 0x158 (i64.load offset=0x158 align=1 (i32.const 0)))
+    (local.set 0x159 (i64.load offset=0x159 align=1 (i32.const 0)))
+    (local.set 0x15a (i64.load offset=0x15a align=1 (i32.const 0)))
+    (local.set 0x15b (i64.load offset=0x15b align=1 (i32.const 0)))
+    (local.set 0x15c (i64.load offset=0x15c align=1 (i32.const 0)))
+    (local.set 0x15d (i64.load offset=0x15d align=1 (i32.const 0)))
+    (local.set 0x15e (i64.load offset=0x15e align=1 (i32.const 0)))
+    (local.set 0x15f (i64.load offset=0x15f align=1 (i32.const 0)))
+    (local.set 0x160 (i64.load offset=0x160 align=1 (i32.const 0)))
+    (local.set 0x161 (i64.load offset=0x161 align=1 (i32.const 0)))
+    (local.set 0x162 (i64.load offset=0x162 align=1 (i32.const 0)))
+    (local.set 0x163 (i64.load offset=0x163 align=1 (i32.const 0)))
+    (local.set 0x164 (i64.load offset=0x164 align=1 (i32.const 0)))
+    (local.set 0x165 (i64.load offset=0x165 align=1 (i32.const 0)))
+    (local.set 0x166 (i64.load offset=0x166 align=1 (i32.const 0)))
+    (local.set 0x167 (i64.load offset=0x167 align=1 (i32.const 0)))
+    (local.set 0x168 (i64.load offset=0x168 align=1 (i32.const 0)))
+    (local.set 0x169 (i64.load offset=0x169 align=1 (i32.const 0)))
+    (local.set 0x16a (i64.load offset=0x16a align=1 (i32.const 0)))
+    (local.set 0x16b (i64.load offset=0x16b align=1 (i32.const 0)))
+    (local.set 0x16c (i64.load offset=0x16c align=1 (i32.const 0)))
+    (local.set 0x16d (i64.load offset=0x16d align=1 (i32.const 0)))
+    (local.set 0x16e (i64.load offset=0x16e align=1 (i32.const 0)))
+    (local.set 0x16f (i64.load offset=0x16f align=1 (i32.const 0)))
+    (local.set 0x170 (i64.load offset=0x170 align=1 (i32.const 0)))
+    (local.set 0x171 (i64.load offset=0x171 align=1 (i32.const 0)))
+    (local.set 0x172 (i64.load offset=0x172 align=1 (i32.const 0)))
+    (local.set 0x173 (i64.load offset=0x173 align=1 (i32.const 0)))
+    (local.set 0x174 (i64.load offset=0x174 align=1 (i32.const 0)))
+    (local.set 0x175 (i64.load offset=0x175 align=1 (i32.const 0)))
+    (local.set 0x176 (i64.load offset=0x176 align=1 (i32.const 0)))
+    (local.set 0x177 (i64.load offset=0x177 align=1 (i32.const 0)))
+    (local.set 0x178 (i64.load offset=0x178 align=1 (i32.const 0)))
+    (local.set 0x179 (i64.load offset=0x179 align=1 (i32.const 0)))
+    (local.set 0x17a (i64.load offset=0x17a align=1 (i32.const 0)))
+    (local.set 0x17b (i64.load offset=0x17b align=1 (i32.const 0)))
+    (local.set 0x17c (i64.load offset=0x17c align=1 (i32.const 0)))
+    (local.set 0x17d (i64.load offset=0x17d align=1 (i32.const 0)))
+    (local.set 0x17e (i64.load offset=0x17e align=1 (i32.const 0)))
+    (local.set 0x17f (i64.load offset=0x17f align=1 (i32.const 0)))
+    (local.set 0x180 (i64.load offset=0x180 align=1 (i32.const 0)))
+    (local.set 0x181 (i64.load offset=0x181 align=1 (i32.const 0)))
+    (local.set 0x182 (i64.load offset=0x182 align=1 (i32.const 0)))
+    (local.set 0x183 (i64.load offset=0x183 align=1 (i32.const 0)))
+    (local.set 0x184 (i64.load offset=0x184 align=1 (i32.const 0)))
+    (local.set 0x185 (i64.load offset=0x185 align=1 (i32.const 0)))
+    (local.set 0x186 (i64.load offset=0x186 align=1 (i32.const 0)))
+    (local.set 0x187 (i64.load offset=0x187 align=1 (i32.const 0)))
+    (local.set 0x188 (i64.load offset=0x188 align=1 (i32.const 0)))
+    (local.set 0x189 (i64.load offset=0x189 align=1 (i32.const 0)))
+    (local.set 0x18a (i64.load offset=0x18a align=1 (i32.const 0)))
+    (local.set 0x18b (i64.load offset=0x18b align=1 (i32.const 0)))
+    (local.set 0x18c (i64.load offset=0x18c align=1 (i32.const 0)))
+    (local.set 0x18d (i64.load offset=0x18d align=1 (i32.const 0)))
+    (local.set 0x18e (i64.load offset=0x18e align=1 (i32.const 0)))
+    (local.set 0x18f (i64.load offset=0x18f align=1 (i32.const 0)))
+    (local.set 0x190 (i64.load offset=0x190 align=1 (i32.const 0)))
+    (local.set 0x191 (i64.load offset=0x191 align=1 (i32.const 0)))
+    (local.set 0x192 (i64.load offset=0x192 align=1 (i32.const 0)))
+    (local.set 0x193 (i64.load offset=0x193 align=1 (i32.const 0)))
+    (local.set 0x194 (i64.load offset=0x194 align=1 (i32.const 0)))
+    (local.set 0x195 (i64.load offset=0x195 align=1 (i32.const 0)))
+    (local.set 0x196 (i64.load offset=0x196 align=1 (i32.const 0)))
+    (local.set 0x197 (i64.load offset=0x197 align=1 (i32.const 0)))
+    (local.set 0x198 (i64.load offset=0x198 align=1 (i32.const 0)))
+    (local.set 0x199 (i64.load offset=0x199 align=1 (i32.const 0)))
+    (local.set 0x19a (i64.load offset=0x19a align=1 (i32.const 0)))
+    (local.set 0x19b (i64.load offset=0x19b align=1 (i32.const 0)))
+    (local.set 0x19c (i64.load offset=0x19c align=1 (i32.const 0)))
+    (local.set 0x19d (i64.load offset=0x19d align=1 (i32.const 0)))
+    (local.set 0x19e (i64.load offset=0x19e align=1 (i32.const 0)))
+    (local.set 0x19f (i64.load offset=0x19f align=1 (i32.const 0)))
+    (local.set 0x1a0 (i64.load offset=0x1a0 align=1 (i32.const 0)))
+    (local.set 0x1a1 (i64.load offset=0x1a1 align=1 (i32.const 0)))
+    (local.set 0x1a2 (i64.load offset=0x1a2 align=1 (i32.const 0)))
+    (local.set 0x1a3 (i64.load offset=0x1a3 align=1 (i32.const 0)))
+    (local.set 0x1a4 (i64.load offset=0x1a4 align=1 (i32.const 0)))
+    (local.set 0x1a5 (i64.load offset=0x1a5 align=1 (i32.const 0)))
+    (local.set 0x1a6 (i64.load offset=0x1a6 align=1 (i32.const 0)))
+    (local.set 0x1a7 (i64.load offset=0x1a7 align=1 (i32.const 0)))
+    (local.set 0x1a8 (i64.load offset=0x1a8 align=1 (i32.const 0)))
+    (local.set 0x1a9 (i64.load offset=0x1a9 align=1 (i32.const 0)))
+    (local.set 0x1aa (i64.load offset=0x1aa align=1 (i32.const 0)))
+    (local.set 0x1ab (i64.load offset=0x1ab align=1 (i32.const 0)))
+    (local.set 0x1ac (i64.load offset=0x1ac align=1 (i32.const 0)))
+    (local.set 0x1ad (i64.load offset=0x1ad align=1 (i32.const 0)))
+    (local.set 0x1ae (i64.load offset=0x1ae align=1 (i32.const 0)))
+    (local.set 0x1af (i64.load offset=0x1af align=1 (i32.const 0)))
+    (local.set 0x1b0 (i64.load offset=0x1b0 align=1 (i32.const 0)))
+    (local.set 0x1b1 (i64.load offset=0x1b1 align=1 (i32.const 0)))
+    (local.set 0x1b2 (i64.load offset=0x1b2 align=1 (i32.const 0)))
+    (local.set 0x1b3 (i64.load offset=0x1b3 align=1 (i32.const 0)))
+    (local.set 0x1b4 (i64.load offset=0x1b4 align=1 (i32.const 0)))
+    (local.set 0x1b5 (i64.load offset=0x1b5 align=1 (i32.const 0)))
+    (local.set 0x1b6 (i64.load offset=0x1b6 align=1 (i32.const 0)))
+    (local.set 0x1b7 (i64.load offset=0x1b7 align=1 (i32.const 0)))
+    (local.set 0x1b8 (i64.load offset=0x1b8 align=1 (i32.const 0)))
+    (local.set 0x1b9 (i64.load offset=0x1b9 align=1 (i32.const 0)))
+    (local.set 0x1ba (i64.load offset=0x1ba align=1 (i32.const 0)))
+    (local.set 0x1bb (i64.load offset=0x1bb align=1 (i32.const 0)))
+    (local.set 0x1bc (i64.load offset=0x1bc align=1 (i32.const 0)))
+    (local.set 0x1bd (i64.load offset=0x1bd align=1 (i32.const 0)))
+    (local.set 0x1be (i64.load offset=0x1be align=1 (i32.const 0)))
+    (local.set 0x1bf (i64.load offset=0x1bf align=1 (i32.const 0)))
+    (local.set 0x1c0 (i64.load offset=0x1c0 align=1 (i32.const 0)))
+    (local.set 0x1c1 (i64.load offset=0x1c1 align=1 (i32.const 0)))
+    (local.set 0x1c2 (i64.load offset=0x1c2 align=1 (i32.const 0)))
+    (local.set 0x1c3 (i64.load offset=0x1c3 align=1 (i32.const 0)))
+    (local.set 0x1c4 (i64.load offset=0x1c4 align=1 (i32.const 0)))
+    (local.set 0x1c5 (i64.load offset=0x1c5 align=1 (i32.const 0)))
+    (local.set 0x1c6 (i64.load offset=0x1c6 align=1 (i32.const 0)))
+    (local.set 0x1c7 (i64.load offset=0x1c7 align=1 (i32.const 0)))
+    (local.set 0x1c8 (i64.load offset=0x1c8 align=1 (i32.const 0)))
+    (local.set 0x1c9 (i64.load offset=0x1c9 align=1 (i32.const 0)))
+    (local.set 0x1ca (i64.load offset=0x1ca align=1 (i32.const 0)))
+    (local.set 0x1cb (i64.load offset=0x1cb align=1 (i32.const 0)))
+    (local.set 0x1cc (i64.load offset=0x1cc align=1 (i32.const 0)))
+    (local.set 0x1cd (i64.load offset=0x1cd align=1 (i32.const 0)))
+    (local.set 0x1ce (i64.load offset=0x1ce align=1 (i32.const 0)))
+    (local.set 0x1cf (i64.load offset=0x1cf align=1 (i32.const 0)))
+    (local.set 0x1d0 (i64.load offset=0x1d0 align=1 (i32.const 0)))
+    (local.set 0x1d1 (i64.load offset=0x1d1 align=1 (i32.const 0)))
+    (local.set 0x1d2 (i64.load offset=0x1d2 align=1 (i32.const 0)))
+    (local.set 0x1d3 (i64.load offset=0x1d3 align=1 (i32.const 0)))
+    (local.set 0x1d4 (i64.load offset=0x1d4 align=1 (i32.const 0)))
+    (local.set 0x1d5 (i64.load offset=0x1d5 align=1 (i32.const 0)))
+    (local.set 0x1d6 (i64.load offset=0x1d6 align=1 (i32.const 0)))
+    (local.set 0x1d7 (i64.load offset=0x1d7 align=1 (i32.const 0)))
+    (local.set 0x1d8 (i64.load offset=0x1d8 align=1 (i32.const 0)))
+    (local.set 0x1d9 (i64.load offset=0x1d9 align=1 (i32.const 0)))
+    (local.set 0x1da (i64.load offset=0x1da align=1 (i32.const 0)))
+    (local.set 0x1db (i64.load offset=0x1db align=1 (i32.const 0)))
+    (local.set 0x1dc (i64.load offset=0x1dc align=1 (i32.const 0)))
+    (local.set 0x1dd (i64.load offset=0x1dd align=1 (i32.const 0)))
+    (local.set 0x1de (i64.load offset=0x1de align=1 (i32.const 0)))
+    (local.set 0x1df (i64.load offset=0x1df align=1 (i32.const 0)))
+    (local.set 0x1e0 (i64.load offset=0x1e0 align=1 (i32.const 0)))
+    (local.set 0x1e1 (i64.load offset=0x1e1 align=1 (i32.const 0)))
+    (local.set 0x1e2 (i64.load offset=0x1e2 align=1 (i32.const 0)))
+    (local.set 0x1e3 (i64.load offset=0x1e3 align=1 (i32.const 0)))
+    (local.set 0x1e4 (i64.load offset=0x1e4 align=1 (i32.const 0)))
+    (local.set 0x1e5 (i64.load offset=0x1e5 align=1 (i32.const 0)))
+    (local.set 0x1e6 (i64.load offset=0x1e6 align=1 (i32.const 0)))
+    (local.set 0x1e7 (i64.load offset=0x1e7 align=1 (i32.const 0)))
+    (local.set 0x1e8 (i64.load offset=0x1e8 align=1 (i32.const 0)))
+    (local.set 0x1e9 (i64.load offset=0x1e9 align=1 (i32.const 0)))
+    (local.set 0x1ea (i64.load offset=0x1ea align=1 (i32.const 0)))
+    (local.set 0x1eb (i64.load offset=0x1eb align=1 (i32.const 0)))
+    (local.set 0x1ec (i64.load offset=0x1ec align=1 (i32.const 0)))
+    (local.set 0x1ed (i64.load offset=0x1ed align=1 (i32.const 0)))
+    (local.set 0x1ee (i64.load offset=0x1ee align=1 (i32.const 0)))
+    (local.set 0x1ef (i64.load offset=0x1ef align=1 (i32.const 0)))
+    (local.set 0x1f0 (i64.load offset=0x1f0 align=1 (i32.const 0)))
+    (local.set 0x1f1 (i64.load offset=0x1f1 align=1 (i32.const 0)))
+    (local.set 0x1f2 (i64.load offset=0x1f2 align=1 (i32.const 0)))
+    (local.set 0x1f3 (i64.load offset=0x1f3 align=1 (i32.const 0)))
+    (local.set 0x1f4 (i64.load offset=0x1f4 align=1 (i32.const 0)))
+    (local.set 0x1f5 (i64.load offset=0x1f5 align=1 (i32.const 0)))
+    (local.set 0x1f6 (i64.load offset=0x1f6 align=1 (i32.const 0)))
+    (local.set 0x1f7 (i64.load offset=0x1f7 align=1 (i32.const 0)))
+    (local.set 0x1f8 (i64.load offset=0x1f8 align=1 (i32.const 0)))
+    (local.set 0x1f9 (i64.load offset=0x1f9 align=1 (i32.const 0)))
+    (local.set 0x1fa (i64.load offset=0x1fa align=1 (i32.const 0)))
+    (local.set 0x1fb (i64.load offset=0x1fb align=1 (i32.const 0)))
+    (local.set 0x1fc (i64.load offset=0x1fc align=1 (i32.const 0)))
+    (local.set 0x1fd (i64.load offset=0x1fd align=1 (i32.const 0)))
+    (local.set 0x1fe (i64.load offset=0x1fe align=1 (i32.const 0)))
+    (local.set 0x1ff (i64.load offset=0x1ff align=1 (i32.const 0)))
+    (local.set 0x200 (i64.load offset=0x200 align=1 (i32.const 0)))
+    (local.set 0x201 (i64.load offset=0x201 align=1 (i32.const 0)))
+    (local.set 0x202 (i64.load offset=0x202 align=1 (i32.const 0)))
+    (local.set 0x203 (i64.load offset=0x203 align=1 (i32.const 0)))
+    (local.set 0x204 (i64.load offset=0x204 align=1 (i32.const 0)))
+    (local.set 0x205 (i64.load offset=0x205 align=1 (i32.const 0)))
+    (local.set 0x206 (i64.load offset=0x206 align=1 (i32.const 0)))
+    (local.set 0x207 (i64.load offset=0x207 align=1 (i32.const 0)))
+    (local.set 0x208 (i64.load offset=0x208 align=1 (i32.const 0)))
+    (local.set 0x209 (i64.load offset=0x209 align=1 (i32.const 0)))
+    (local.set 0x20a (i64.load offset=0x20a align=1 (i32.const 0)))
+    (local.set 0x20b (i64.load offset=0x20b align=1 (i32.const 0)))
+    (local.set 0x20c (i64.load offset=0x20c align=1 (i32.const 0)))
+    (local.set 0x20d (i64.load offset=0x20d align=1 (i32.const 0)))
+    (local.set 0x20e (i64.load offset=0x20e align=1 (i32.const 0)))
+    (local.set 0x20f (i64.load offset=0x20f align=1 (i32.const 0)))
+    (local.set 0x210 (i64.load offset=0x210 align=1 (i32.const 0)))
+    (local.set 0x211 (i64.load offset=0x211 align=1 (i32.const 0)))
+    (local.set 0x212 (i64.load offset=0x212 align=1 (i32.const 0)))
+    (local.set 0x213 (i64.load offset=0x213 align=1 (i32.const 0)))
+    (local.set 0x214 (i64.load offset=0x214 align=1 (i32.const 0)))
+    (local.set 0x215 (i64.load offset=0x215 align=1 (i32.const 0)))
+    (local.set 0x216 (i64.load offset=0x216 align=1 (i32.const 0)))
+    (local.set 0x217 (i64.load offset=0x217 align=1 (i32.const 0)))
+    (local.set 0x218 (i64.load offset=0x218 align=1 (i32.const 0)))
+    (local.set 0x219 (i64.load offset=0x219 align=1 (i32.const 0)))
+    (local.set 0x21a (i64.load offset=0x21a align=1 (i32.const 0)))
+    (local.set 0x21b (i64.load offset=0x21b align=1 (i32.const 0)))
+    (local.set 0x21c (i64.load offset=0x21c align=1 (i32.const 0)))
+    (local.set 0x21d (i64.load offset=0x21d align=1 (i32.const 0)))
+    (local.set 0x21e (i64.load offset=0x21e align=1 (i32.const 0)))
+    (local.set 0x21f (i64.load offset=0x21f align=1 (i32.const 0)))
+    (local.set 0x220 (i64.load offset=0x220 align=1 (i32.const 0)))
+    (local.set 0x221 (i64.load offset=0x221 align=1 (i32.const 0)))
+    (local.set 0x222 (i64.load offset=0x222 align=1 (i32.const 0)))
+    (local.set 0x223 (i64.load offset=0x223 align=1 (i32.const 0)))
+    (local.set 0x224 (i64.load offset=0x224 align=1 (i32.const 0)))
+    (local.set 0x225 (i64.load offset=0x225 align=1 (i32.const 0)))
+    (local.set 0x226 (i64.load offset=0x226 align=1 (i32.const 0)))
+    (local.set 0x227 (i64.load offset=0x227 align=1 (i32.const 0)))
+    (local.set 0x228 (i64.load offset=0x228 align=1 (i32.const 0)))
+    (local.set 0x229 (i64.load offset=0x229 align=1 (i32.const 0)))
+    (local.set 0x22a (i64.load offset=0x22a align=1 (i32.const 0)))
+    (local.set 0x22b (i64.load offset=0x22b align=1 (i32.const 0)))
+    (local.set 0x22c (i64.load offset=0x22c align=1 (i32.const 0)))
+    (local.set 0x22d (i64.load offset=0x22d align=1 (i32.const 0)))
+    (local.set 0x22e (i64.load offset=0x22e align=1 (i32.const 0)))
+    (local.set 0x22f (i64.load offset=0x22f align=1 (i32.const 0)))
+    (local.set 0x230 (i64.load offset=0x230 align=1 (i32.const 0)))
+    (local.set 0x231 (i64.load offset=0x231 align=1 (i32.const 0)))
+    (local.set 0x232 (i64.load offset=0x232 align=1 (i32.const 0)))
+    (local.set 0x233 (i64.load offset=0x233 align=1 (i32.const 0)))
+    (local.set 0x234 (i64.load offset=0x234 align=1 (i32.const 0)))
+    (local.set 0x235 (i64.load offset=0x235 align=1 (i32.const 0)))
+    (local.set 0x236 (i64.load offset=0x236 align=1 (i32.const 0)))
+    (local.set 0x237 (i64.load offset=0x237 align=1 (i32.const 0)))
+    (local.set 0x238 (i64.load offset=0x238 align=1 (i32.const 0)))
+    (local.set 0x239 (i64.load offset=0x239 align=1 (i32.const 0)))
+    (local.set 0x23a (i64.load offset=0x23a align=1 (i32.const 0)))
+    (local.set 0x23b (i64.load offset=0x23b align=1 (i32.const 0)))
+    (local.set 0x23c (i64.load offset=0x23c align=1 (i32.const 0)))
+    (local.set 0x23d (i64.load offset=0x23d align=1 (i32.const 0)))
+    (local.set 0x23e (i64.load offset=0x23e align=1 (i32.const 0)))
+    (local.set 0x23f (i64.load offset=0x23f align=1 (i32.const 0)))
+    (local.set 0x240 (i64.load offset=0x240 align=1 (i32.const 0)))
+    (local.set 0x241 (i64.load offset=0x241 align=1 (i32.const 0)))
+    (local.set 0x242 (i64.load offset=0x242 align=1 (i32.const 0)))
+    (local.set 0x243 (i64.load offset=0x243 align=1 (i32.const 0)))
+    (local.set 0x244 (i64.load offset=0x244 align=1 (i32.const 0)))
+    (local.set 0x245 (i64.load offset=0x245 align=1 (i32.const 0)))
+    (local.set 0x246 (i64.load offset=0x246 align=1 (i32.const 0)))
+    (local.set 0x247 (i64.load offset=0x247 align=1 (i32.const 0)))
+    (local.set 0x248 (i64.load offset=0x248 align=1 (i32.const 0)))
+    (local.set 0x249 (i64.load offset=0x249 align=1 (i32.const 0)))
+    (local.set 0x24a (i64.load offset=0x24a align=1 (i32.const 0)))
+    (local.set 0x24b (i64.load offset=0x24b align=1 (i32.const 0)))
+    (local.set 0x24c (i64.load offset=0x24c align=1 (i32.const 0)))
+    (local.set 0x24d (i64.load offset=0x24d align=1 (i32.const 0)))
+    (local.set 0x24e (i64.load offset=0x24e align=1 (i32.const 0)))
+    (local.set 0x24f (i64.load offset=0x24f align=1 (i32.const 0)))
+    (local.set 0x250 (i64.load offset=0x250 align=1 (i32.const 0)))
+    (local.set 0x251 (i64.load offset=0x251 align=1 (i32.const 0)))
+    (local.set 0x252 (i64.load offset=0x252 align=1 (i32.const 0)))
+    (local.set 0x253 (i64.load offset=0x253 align=1 (i32.const 0)))
+    (local.set 0x254 (i64.load offset=0x254 align=1 (i32.const 0)))
+    (local.set 0x255 (i64.load offset=0x255 align=1 (i32.const 0)))
+    (local.set 0x256 (i64.load offset=0x256 align=1 (i32.const 0)))
+    (local.set 0x257 (i64.load offset=0x257 align=1 (i32.const 0)))
+    (local.set 0x258 (i64.load offset=0x258 align=1 (i32.const 0)))
+    (local.set 0x259 (i64.load offset=0x259 align=1 (i32.const 0)))
+    (local.set 0x25a (i64.load offset=0x25a align=1 (i32.const 0)))
+    (local.set 0x25b (i64.load offset=0x25b align=1 (i32.const 0)))
+    (local.set 0x25c (i64.load offset=0x25c align=1 (i32.const 0)))
+    (local.set 0x25d (i64.load offset=0x25d align=1 (i32.const 0)))
+    (local.set 0x25e (i64.load offset=0x25e align=1 (i32.const 0)))
+    (local.set 0x25f (i64.load offset=0x25f align=1 (i32.const 0)))
+    (local.set 0x260 (i64.load offset=0x260 align=1 (i32.const 0)))
+    (local.set 0x261 (i64.load offset=0x261 align=1 (i32.const 0)))
+    (local.set 0x262 (i64.load offset=0x262 align=1 (i32.const 0)))
+    (local.set 0x263 (i64.load offset=0x263 align=1 (i32.const 0)))
+    (local.set 0x264 (i64.load offset=0x264 align=1 (i32.const 0)))
+    (local.set 0x265 (i64.load offset=0x265 align=1 (i32.const 0)))
+    (local.set 0x266 (i64.load offset=0x266 align=1 (i32.const 0)))
+    (local.set 0x267 (i64.load offset=0x267 align=1 (i32.const 0)))
+    (local.set 0x268 (i64.load offset=0x268 align=1 (i32.const 0)))
+    (local.set 0x269 (i64.load offset=0x269 align=1 (i32.const 0)))
+    (local.set 0x26a (i64.load offset=0x26a align=1 (i32.const 0)))
+    (local.set 0x26b (i64.load offset=0x26b align=1 (i32.const 0)))
+    (local.set 0x26c (i64.load offset=0x26c align=1 (i32.const 0)))
+    (local.set 0x26d (i64.load offset=0x26d align=1 (i32.const 0)))
+    (local.set 0x26e (i64.load offset=0x26e align=1 (i32.const 0)))
+    (local.set 0x26f (i64.load offset=0x26f align=1 (i32.const 0)))
+    (local.set 0x270 (i64.load offset=0x270 align=1 (i32.const 0)))
+    (local.set 0x271 (i64.load offset=0x271 align=1 (i32.const 0)))
+    (local.set 0x272 (i64.load offset=0x272 align=1 (i32.const 0)))
+    (local.set 0x273 (i64.load offset=0x273 align=1 (i32.const 0)))
+    (local.set 0x274 (i64.load offset=0x274 align=1 (i32.const 0)))
+    (local.set 0x275 (i64.load offset=0x275 align=1 (i32.const 0)))
+    (local.set 0x276 (i64.load offset=0x276 align=1 (i32.const 0)))
+    (local.set 0x277 (i64.load offset=0x277 align=1 (i32.const 0)))
+    (local.set 0x278 (i64.load offset=0x278 align=1 (i32.const 0)))
+    (local.set 0x279 (i64.load offset=0x279 align=1 (i32.const 0)))
+    (local.set 0x27a (i64.load offset=0x27a align=1 (i32.const 0)))
+    (local.set 0x27b (i64.load offset=0x27b align=1 (i32.const 0)))
+    (local.set 0x27c (i64.load offset=0x27c align=1 (i32.const 0)))
+    (local.set 0x27d (i64.load offset=0x27d align=1 (i32.const 0)))
+    (local.set 0x27e (i64.load offset=0x27e align=1 (i32.const 0)))
+    (local.set 0x27f (i64.load offset=0x27f align=1 (i32.const 0)))
+    (local.set 0x280 (i64.load offset=0x280 align=1 (i32.const 0)))
+    (local.set 0x281 (i64.load offset=0x281 align=1 (i32.const 0)))
+    (local.set 0x282 (i64.load offset=0x282 align=1 (i32.const 0)))
+    (local.set 0x283 (i64.load offset=0x283 align=1 (i32.const 0)))
+    (local.set 0x284 (i64.load offset=0x284 align=1 (i32.const 0)))
+    (local.set 0x285 (i64.load offset=0x285 align=1 (i32.const 0)))
+    (local.set 0x286 (i64.load offset=0x286 align=1 (i32.const 0)))
+    (local.set 0x287 (i64.load offset=0x287 align=1 (i32.const 0)))
+    (local.set 0x288 (i64.load offset=0x288 align=1 (i32.const 0)))
+    (local.set 0x289 (i64.load offset=0x289 align=1 (i32.const 0)))
+    (local.set 0x28a (i64.load offset=0x28a align=1 (i32.const 0)))
+    (local.set 0x28b (i64.load offset=0x28b align=1 (i32.const 0)))
+    (local.set 0x28c (i64.load offset=0x28c align=1 (i32.const 0)))
+    (local.set 0x28d (i64.load offset=0x28d align=1 (i32.const 0)))
+    (local.set 0x28e (i64.load offset=0x28e align=1 (i32.const 0)))
+    (local.set 0x28f (i64.load offset=0x28f align=1 (i32.const 0)))
+    (local.set 0x290 (i64.load offset=0x290 align=1 (i32.const 0)))
+    (local.set 0x291 (i64.load offset=0x291 align=1 (i32.const 0)))
+    (local.set 0x292 (i64.load offset=0x292 align=1 (i32.const 0)))
+    (local.set 0x293 (i64.load offset=0x293 align=1 (i32.const 0)))
+    (local.set 0x294 (i64.load offset=0x294 align=1 (i32.const 0)))
+    (local.set 0x295 (i64.load offset=0x295 align=1 (i32.const 0)))
+    (local.set 0x296 (i64.load offset=0x296 align=1 (i32.const 0)))
+    (local.set 0x297 (i64.load offset=0x297 align=1 (i32.const 0)))
+    (local.set 0x298 (i64.load offset=0x298 align=1 (i32.const 0)))
+    (local.set 0x299 (i64.load offset=0x299 align=1 (i32.const 0)))
+    (local.set 0x29a (i64.load offset=0x29a align=1 (i32.const 0)))
+    (local.set 0x29b (i64.load offset=0x29b align=1 (i32.const 0)))
+    (local.set 0x29c (i64.load offset=0x29c align=1 (i32.const 0)))
+    (local.set 0x29d (i64.load offset=0x29d align=1 (i32.const 0)))
+    (local.set 0x29e (i64.load offset=0x29e align=1 (i32.const 0)))
+    (local.set 0x29f (i64.load offset=0x29f align=1 (i32.const 0)))
+    (local.set 0x2a0 (i64.load offset=0x2a0 align=1 (i32.const 0)))
+    (local.set 0x2a1 (i64.load offset=0x2a1 align=1 (i32.const 0)))
+    (local.set 0x2a2 (i64.load offset=0x2a2 align=1 (i32.const 0)))
+    (local.set 0x2a3 (i64.load offset=0x2a3 align=1 (i32.const 0)))
+    (local.set 0x2a4 (i64.load offset=0x2a4 align=1 (i32.const 0)))
+    (local.set 0x2a5 (i64.load offset=0x2a5 align=1 (i32.const 0)))
+    (local.set 0x2a6 (i64.load offset=0x2a6 align=1 (i32.const 0)))
+    (local.set 0x2a7 (i64.load offset=0x2a7 align=1 (i32.const 0)))
+    (local.set 0x2a8 (i64.load offset=0x2a8 align=1 (i32.const 0)))
+    (local.set 0x2a9 (i64.load offset=0x2a9 align=1 (i32.const 0)))
+    (local.set 0x2aa (i64.load offset=0x2aa align=1 (i32.const 0)))
+    (local.set 0x2ab (i64.load offset=0x2ab align=1 (i32.const 0)))
+    (local.set 0x2ac (i64.load offset=0x2ac align=1 (i32.const 0)))
+    (local.set 0x2ad (i64.load offset=0x2ad align=1 (i32.const 0)))
+    (local.set 0x2ae (i64.load offset=0x2ae align=1 (i32.const 0)))
+    (local.set 0x2af (i64.load offset=0x2af align=1 (i32.const 0)))
+    (local.set 0x2b0 (i64.load offset=0x2b0 align=1 (i32.const 0)))
+    (local.set 0x2b1 (i64.load offset=0x2b1 align=1 (i32.const 0)))
+    (local.set 0x2b2 (i64.load offset=0x2b2 align=1 (i32.const 0)))
+    (local.set 0x2b3 (i64.load offset=0x2b3 align=1 (i32.const 0)))
+    (local.set 0x2b4 (i64.load offset=0x2b4 align=1 (i32.const 0)))
+    (local.set 0x2b5 (i64.load offset=0x2b5 align=1 (i32.const 0)))
+    (local.set 0x2b6 (i64.load offset=0x2b6 align=1 (i32.const 0)))
+    (local.set 0x2b7 (i64.load offset=0x2b7 align=1 (i32.const 0)))
+    (local.set 0x2b8 (i64.load offset=0x2b8 align=1 (i32.const 0)))
+    (local.set 0x2b9 (i64.load offset=0x2b9 align=1 (i32.const 0)))
+    (local.set 0x2ba (i64.load offset=0x2ba align=1 (i32.const 0)))
+    (local.set 0x2bb (i64.load offset=0x2bb align=1 (i32.const 0)))
+    (local.set 0x2bc (i64.load offset=0x2bc align=1 (i32.const 0)))
+    (local.set 0x2bd (i64.load offset=0x2bd align=1 (i32.const 0)))
+    (local.set 0x2be (i64.load offset=0x2be align=1 (i32.const 0)))
+    (local.set 0x2bf (i64.load offset=0x2bf align=1 (i32.const 0)))
+    (local.set 0x2c0 (i64.load offset=0x2c0 align=1 (i32.const 0)))
+    (local.set 0x2c1 (i64.load offset=0x2c1 align=1 (i32.const 0)))
+    (local.set 0x2c2 (i64.load offset=0x2c2 align=1 (i32.const 0)))
+    (local.set 0x2c3 (i64.load offset=0x2c3 align=1 (i32.const 0)))
+    (local.set 0x2c4 (i64.load offset=0x2c4 align=1 (i32.const 0)))
+    (local.set 0x2c5 (i64.load offset=0x2c5 align=1 (i32.const 0)))
+    (local.set 0x2c6 (i64.load offset=0x2c6 align=1 (i32.const 0)))
+    (local.set 0x2c7 (i64.load offset=0x2c7 align=1 (i32.const 0)))
+    (local.set 0x2c8 (i64.load offset=0x2c8 align=1 (i32.const 0)))
+    (local.set 0x2c9 (i64.load offset=0x2c9 align=1 (i32.const 0)))
+    (local.set 0x2ca (i64.load offset=0x2ca align=1 (i32.const 0)))
+    (local.set 0x2cb (i64.load offset=0x2cb align=1 (i32.const 0)))
+    (local.set 0x2cc (i64.load offset=0x2cc align=1 (i32.const 0)))
+    (local.set 0x2cd (i64.load offset=0x2cd align=1 (i32.const 0)))
+    (local.set 0x2ce (i64.load offset=0x2ce align=1 (i32.const 0)))
+    (local.set 0x2cf (i64.load offset=0x2cf align=1 (i32.const 0)))
+    (local.set 0x2d0 (i64.load offset=0x2d0 align=1 (i32.const 0)))
+    (local.set 0x2d1 (i64.load offset=0x2d1 align=1 (i32.const 0)))
+    (local.set 0x2d2 (i64.load offset=0x2d2 align=1 (i32.const 0)))
+    (local.set 0x2d3 (i64.load offset=0x2d3 align=1 (i32.const 0)))
+    (local.set 0x2d4 (i64.load offset=0x2d4 align=1 (i32.const 0)))
+    (local.set 0x2d5 (i64.load offset=0x2d5 align=1 (i32.const 0)))
+    (local.set 0x2d6 (i64.load offset=0x2d6 align=1 (i32.const 0)))
+    (local.set 0x2d7 (i64.load offset=0x2d7 align=1 (i32.const 0)))
+    (local.set 0x2d8 (i64.load offset=0x2d8 align=1 (i32.const 0)))
+    (local.set 0x2d9 (i64.load offset=0x2d9 align=1 (i32.const 0)))
+    (local.set 0x2da (i64.load offset=0x2da align=1 (i32.const 0)))
+    (local.set 0x2db (i64.load offset=0x2db align=1 (i32.const 0)))
+    (local.set 0x2dc (i64.load offset=0x2dc align=1 (i32.const 0)))
+    (local.set 0x2dd (i64.load offset=0x2dd align=1 (i32.const 0)))
+    (local.set 0x2de (i64.load offset=0x2de align=1 (i32.const 0)))
+    (local.set 0x2df (i64.load offset=0x2df align=1 (i32.const 0)))
+    (local.set 0x2e0 (i64.load offset=0x2e0 align=1 (i32.const 0)))
+    (local.set 0x2e1 (i64.load offset=0x2e1 align=1 (i32.const 0)))
+    (local.set 0x2e2 (i64.load offset=0x2e2 align=1 (i32.const 0)))
+    (local.set 0x2e3 (i64.load offset=0x2e3 align=1 (i32.const 0)))
+    (local.set 0x2e4 (i64.load offset=0x2e4 align=1 (i32.const 0)))
+    (local.set 0x2e5 (i64.load offset=0x2e5 align=1 (i32.const 0)))
+    (local.set 0x2e6 (i64.load offset=0x2e6 align=1 (i32.const 0)))
+    (local.set 0x2e7 (i64.load offset=0x2e7 align=1 (i32.const 0)))
+    (local.set 0x2e8 (i64.load offset=0x2e8 align=1 (i32.const 0)))
+    (local.set 0x2e9 (i64.load offset=0x2e9 align=1 (i32.const 0)))
+    (local.set 0x2ea (i64.load offset=0x2ea align=1 (i32.const 0)))
+    (local.set 0x2eb (i64.load offset=0x2eb align=1 (i32.const 0)))
+    (local.set 0x2ec (i64.load offset=0x2ec align=1 (i32.const 0)))
+    (local.set 0x2ed (i64.load offset=0x2ed align=1 (i32.const 0)))
+    (local.set 0x2ee (i64.load offset=0x2ee align=1 (i32.const 0)))
+    (local.set 0x2ef (i64.load offset=0x2ef align=1 (i32.const 0)))
+    (local.set 0x2f0 (i64.load offset=0x2f0 align=1 (i32.const 0)))
+    (local.set 0x2f1 (i64.load offset=0x2f1 align=1 (i32.const 0)))
+    (local.set 0x2f2 (i64.load offset=0x2f2 align=1 (i32.const 0)))
+    (local.set 0x2f3 (i64.load offset=0x2f3 align=1 (i32.const 0)))
+    (local.set 0x2f4 (i64.load offset=0x2f4 align=1 (i32.const 0)))
+    (local.set 0x2f5 (i64.load offset=0x2f5 align=1 (i32.const 0)))
+    (local.set 0x2f6 (i64.load offset=0x2f6 align=1 (i32.const 0)))
+    (local.set 0x2f7 (i64.load offset=0x2f7 align=1 (i32.const 0)))
+    (local.set 0x2f8 (i64.load offset=0x2f8 align=1 (i32.const 0)))
+    (local.set 0x2f9 (i64.load offset=0x2f9 align=1 (i32.const 0)))
+    (local.set 0x2fa (i64.load offset=0x2fa align=1 (i32.const 0)))
+    (local.set 0x2fb (i64.load offset=0x2fb align=1 (i32.const 0)))
+    (local.set 0x2fc (i64.load offset=0x2fc align=1 (i32.const 0)))
+    (local.set 0x2fd (i64.load offset=0x2fd align=1 (i32.const 0)))
+    (local.set 0x2fe (i64.load offset=0x2fe align=1 (i32.const 0)))
+    (local.set 0x2ff (i64.load offset=0x2ff align=1 (i32.const 0)))
+    (local.set 0x300 (i64.load offset=0x300 align=1 (i32.const 0)))
+    (local.set 0x301 (i64.load offset=0x301 align=1 (i32.const 0)))
+    (local.set 0x302 (i64.load offset=0x302 align=1 (i32.const 0)))
+    (local.set 0x303 (i64.load offset=0x303 align=1 (i32.const 0)))
+    (local.set 0x304 (i64.load offset=0x304 align=1 (i32.const 0)))
+    (local.set 0x305 (i64.load offset=0x305 align=1 (i32.const 0)))
+    (local.set 0x306 (i64.load offset=0x306 align=1 (i32.const 0)))
+    (local.set 0x307 (i64.load offset=0x307 align=1 (i32.const 0)))
+    (local.set 0x308 (i64.load offset=0x308 align=1 (i32.const 0)))
+    (local.set 0x309 (i64.load offset=0x309 align=1 (i32.const 0)))
+    (local.set 0x30a (i64.load offset=0x30a align=1 (i32.const 0)))
+    (local.set 0x30b (i64.load offset=0x30b align=1 (i32.const 0)))
+    (local.set 0x30c (i64.load offset=0x30c align=1 (i32.const 0)))
+    (local.set 0x30d (i64.load offset=0x30d align=1 (i32.const 0)))
+    (local.set 0x30e (i64.load offset=0x30e align=1 (i32.const 0)))
+    (local.set 0x30f (i64.load offset=0x30f align=1 (i32.const 0)))
+    (local.set 0x310 (i64.load offset=0x310 align=1 (i32.const 0)))
+    (local.set 0x311 (i64.load offset=0x311 align=1 (i32.const 0)))
+    (local.set 0x312 (i64.load offset=0x312 align=1 (i32.const 0)))
+    (local.set 0x313 (i64.load offset=0x313 align=1 (i32.const 0)))
+    (local.set 0x314 (i64.load offset=0x314 align=1 (i32.const 0)))
+    (local.set 0x315 (i64.load offset=0x315 align=1 (i32.const 0)))
+    (local.set 0x316 (i64.load offset=0x316 align=1 (i32.const 0)))
+    (local.set 0x317 (i64.load offset=0x317 align=1 (i32.const 0)))
+    (local.set 0x318 (i64.load offset=0x318 align=1 (i32.const 0)))
+    (local.set 0x319 (i64.load offset=0x319 align=1 (i32.const 0)))
+    (local.set 0x31a (i64.load offset=0x31a align=1 (i32.const 0)))
+    (local.set 0x31b (i64.load offset=0x31b align=1 (i32.const 0)))
+    (local.set 0x31c (i64.load offset=0x31c align=1 (i32.const 0)))
+    (local.set 0x31d (i64.load offset=0x31d align=1 (i32.const 0)))
+    (local.set 0x31e (i64.load offset=0x31e align=1 (i32.const 0)))
+    (local.set 0x31f (i64.load offset=0x31f align=1 (i32.const 0)))
+    (local.set 0x320 (i64.load offset=0x320 align=1 (i32.const 0)))
+    (local.set 0x321 (i64.load offset=0x321 align=1 (i32.const 0)))
+    (local.set 0x322 (i64.load offset=0x322 align=1 (i32.const 0)))
+    (local.set 0x323 (i64.load offset=0x323 align=1 (i32.const 0)))
+    (local.set 0x324 (i64.load offset=0x324 align=1 (i32.const 0)))
+    (local.set 0x325 (i64.load offset=0x325 align=1 (i32.const 0)))
+    (local.set 0x326 (i64.load offset=0x326 align=1 (i32.const 0)))
+    (local.set 0x327 (i64.load offset=0x327 align=1 (i32.const 0)))
+    (local.set 0x328 (i64.load offset=0x328 align=1 (i32.const 0)))
+    (local.set 0x329 (i64.load offset=0x329 align=1 (i32.const 0)))
+    (local.set 0x32a (i64.load offset=0x32a align=1 (i32.const 0)))
+    (local.set 0x32b (i64.load offset=0x32b align=1 (i32.const 0)))
+    (local.set 0x32c (i64.load offset=0x32c align=1 (i32.const 0)))
+    (local.set 0x32d (i64.load offset=0x32d align=1 (i32.const 0)))
+    (local.set 0x32e (i64.load offset=0x32e align=1 (i32.const 0)))
+    (local.set 0x32f (i64.load offset=0x32f align=1 (i32.const 0)))
+    (local.set 0x330 (i64.load offset=0x330 align=1 (i32.const 0)))
+    (local.set 0x331 (i64.load offset=0x331 align=1 (i32.const 0)))
+    (local.set 0x332 (i64.load offset=0x332 align=1 (i32.const 0)))
+    (local.set 0x333 (i64.load offset=0x333 align=1 (i32.const 0)))
+    (local.set 0x334 (i64.load offset=0x334 align=1 (i32.const 0)))
+    (local.set 0x335 (i64.load offset=0x335 align=1 (i32.const 0)))
+    (local.set 0x336 (i64.load offset=0x336 align=1 (i32.const 0)))
+    (local.set 0x337 (i64.load offset=0x337 align=1 (i32.const 0)))
+    (local.set 0x338 (i64.load offset=0x338 align=1 (i32.const 0)))
+    (local.set 0x339 (i64.load offset=0x339 align=1 (i32.const 0)))
+    (local.set 0x33a (i64.load offset=0x33a align=1 (i32.const 0)))
+    (local.set 0x33b (i64.load offset=0x33b align=1 (i32.const 0)))
+    (local.set 0x33c (i64.load offset=0x33c align=1 (i32.const 0)))
+    (local.set 0x33d (i64.load offset=0x33d align=1 (i32.const 0)))
+    (local.set 0x33e (i64.load offset=0x33e align=1 (i32.const 0)))
+    (local.set 0x33f (i64.load offset=0x33f align=1 (i32.const 0)))
+    (local.set 0x340 (i64.load offset=0x340 align=1 (i32.const 0)))
+    (local.set 0x341 (i64.load offset=0x341 align=1 (i32.const 0)))
+    (local.set 0x342 (i64.load offset=0x342 align=1 (i32.const 0)))
+    (local.set 0x343 (i64.load offset=0x343 align=1 (i32.const 0)))
+    (local.set 0x344 (i64.load offset=0x344 align=1 (i32.const 0)))
+    (local.set 0x345 (i64.load offset=0x345 align=1 (i32.const 0)))
+    (local.set 0x346 (i64.load offset=0x346 align=1 (i32.const 0)))
+    (local.set 0x347 (i64.load offset=0x347 align=1 (i32.const 0)))
+    (local.set 0x348 (i64.load offset=0x348 align=1 (i32.const 0)))
+    (local.set 0x349 (i64.load offset=0x349 align=1 (i32.const 0)))
+    (local.set 0x34a (i64.load offset=0x34a align=1 (i32.const 0)))
+    (local.set 0x34b (i64.load offset=0x34b align=1 (i32.const 0)))
+    (local.set 0x34c (i64.load offset=0x34c align=1 (i32.const 0)))
+    (local.set 0x34d (i64.load offset=0x34d align=1 (i32.const 0)))
+    (local.set 0x34e (i64.load offset=0x34e align=1 (i32.const 0)))
+    (local.set 0x34f (i64.load offset=0x34f align=1 (i32.const 0)))
+    (local.set 0x350 (i64.load offset=0x350 align=1 (i32.const 0)))
+    (local.set 0x351 (i64.load offset=0x351 align=1 (i32.const 0)))
+    (local.set 0x352 (i64.load offset=0x352 align=1 (i32.const 0)))
+    (local.set 0x353 (i64.load offset=0x353 align=1 (i32.const 0)))
+    (local.set 0x354 (i64.load offset=0x354 align=1 (i32.const 0)))
+    (local.set 0x355 (i64.load offset=0x355 align=1 (i32.const 0)))
+    (local.set 0x356 (i64.load offset=0x356 align=1 (i32.const 0)))
+    (local.set 0x357 (i64.load offset=0x357 align=1 (i32.const 0)))
+    (local.set 0x358 (i64.load offset=0x358 align=1 (i32.const 0)))
+    (local.set 0x359 (i64.load offset=0x359 align=1 (i32.const 0)))
+    (local.set 0x35a (i64.load offset=0x35a align=1 (i32.const 0)))
+    (local.set 0x35b (i64.load offset=0x35b align=1 (i32.const 0)))
+    (local.set 0x35c (i64.load offset=0x35c align=1 (i32.const 0)))
+    (local.set 0x35d (i64.load offset=0x35d align=1 (i32.const 0)))
+    (local.set 0x35e (i64.load offset=0x35e align=1 (i32.const 0)))
+    (local.set 0x35f (i64.load offset=0x35f align=1 (i32.const 0)))
+    (local.set 0x360 (i64.load offset=0x360 align=1 (i32.const 0)))
+    (local.set 0x361 (i64.load offset=0x361 align=1 (i32.const 0)))
+    (local.set 0x362 (i64.load offset=0x362 align=1 (i32.const 0)))
+    (local.set 0x363 (i64.load offset=0x363 align=1 (i32.const 0)))
+    (local.set 0x364 (i64.load offset=0x364 align=1 (i32.const 0)))
+    (local.set 0x365 (i64.load offset=0x365 align=1 (i32.const 0)))
+    (local.set 0x366 (i64.load offset=0x366 align=1 (i32.const 0)))
+    (local.set 0x367 (i64.load offset=0x367 align=1 (i32.const 0)))
+    (local.set 0x368 (i64.load offset=0x368 align=1 (i32.const 0)))
+    (local.set 0x369 (i64.load offset=0x369 align=1 (i32.const 0)))
+    (local.set 0x36a (i64.load offset=0x36a align=1 (i32.const 0)))
+    (local.set 0x36b (i64.load offset=0x36b align=1 (i32.const 0)))
+    (local.set 0x36c (i64.load offset=0x36c align=1 (i32.const 0)))
+    (local.set 0x36d (i64.load offset=0x36d align=1 (i32.const 0)))
+    (local.set 0x36e (i64.load offset=0x36e align=1 (i32.const 0)))
+    (local.set 0x36f (i64.load offset=0x36f align=1 (i32.const 0)))
+    (local.set 0x370 (i64.load offset=0x370 align=1 (i32.const 0)))
+    (local.set 0x371 (i64.load offset=0x371 align=1 (i32.const 0)))
+    (local.set 0x372 (i64.load offset=0x372 align=1 (i32.const 0)))
+    (local.set 0x373 (i64.load offset=0x373 align=1 (i32.const 0)))
+    (local.set 0x374 (i64.load offset=0x374 align=1 (i32.const 0)))
+    (local.set 0x375 (i64.load offset=0x375 align=1 (i32.const 0)))
+    (local.set 0x376 (i64.load offset=0x376 align=1 (i32.const 0)))
+    (local.set 0x377 (i64.load offset=0x377 align=1 (i32.const 0)))
+    (local.set 0x378 (i64.load offset=0x378 align=1 (i32.const 0)))
+    (local.set 0x379 (i64.load offset=0x379 align=1 (i32.const 0)))
+    (local.set 0x37a (i64.load offset=0x37a align=1 (i32.const 0)))
+    (local.set 0x37b (i64.load offset=0x37b align=1 (i32.const 0)))
+    (local.set 0x37c (i64.load offset=0x37c align=1 (i32.const 0)))
+    (local.set 0x37d (i64.load offset=0x37d align=1 (i32.const 0)))
+    (local.set 0x37e (i64.load offset=0x37e align=1 (i32.const 0)))
+    (local.set 0x37f (i64.load offset=0x37f align=1 (i32.const 0)))
+    (local.set 0x380 (i64.load offset=0x380 align=1 (i32.const 0)))
+    (local.set 0x381 (i64.load offset=0x381 align=1 (i32.const 0)))
+    (local.set 0x382 (i64.load offset=0x382 align=1 (i32.const 0)))
+    (local.set 0x383 (i64.load offset=0x383 align=1 (i32.const 0)))
+    (local.set 0x384 (i64.load offset=0x384 align=1 (i32.const 0)))
+    (local.set 0x385 (i64.load offset=0x385 align=1 (i32.const 0)))
+    (local.set 0x386 (i64.load offset=0x386 align=1 (i32.const 0)))
+    (local.set 0x387 (i64.load offset=0x387 align=1 (i32.const 0)))
+    (local.set 0x388 (i64.load offset=0x388 align=1 (i32.const 0)))
+    (local.set 0x389 (i64.load offset=0x389 align=1 (i32.const 0)))
+    (local.set 0x38a (i64.load offset=0x38a align=1 (i32.const 0)))
+    (local.set 0x38b (i64.load offset=0x38b align=1 (i32.const 0)))
+    (local.set 0x38c (i64.load offset=0x38c align=1 (i32.const 0)))
+    (local.set 0x38d (i64.load offset=0x38d align=1 (i32.const 0)))
+    (local.set 0x38e (i64.load offset=0x38e align=1 (i32.const 0)))
+    (local.set 0x38f (i64.load offset=0x38f align=1 (i32.const 0)))
+    (local.set 0x390 (i64.load offset=0x390 align=1 (i32.const 0)))
+    (local.set 0x391 (i64.load offset=0x391 align=1 (i32.const 0)))
+    (local.set 0x392 (i64.load offset=0x392 align=1 (i32.const 0)))
+    (local.set 0x393 (i64.load offset=0x393 align=1 (i32.const 0)))
+    (local.set 0x394 (i64.load offset=0x394 align=1 (i32.const 0)))
+    (local.set 0x395 (i64.load offset=0x395 align=1 (i32.const 0)))
+    (local.set 0x396 (i64.load offset=0x396 align=1 (i32.const 0)))
+    (local.set 0x397 (i64.load offset=0x397 align=1 (i32.const 0)))
+    (local.set 0x398 (i64.load offset=0x398 align=1 (i32.const 0)))
+    (local.set 0x399 (i64.load offset=0x399 align=1 (i32.const 0)))
+    (local.set 0x39a (i64.load offset=0x39a align=1 (i32.const 0)))
+    (local.set 0x39b (i64.load offset=0x39b align=1 (i32.const 0)))
+    (local.set 0x39c (i64.load offset=0x39c align=1 (i32.const 0)))
+    (local.set 0x39d (i64.load offset=0x39d align=1 (i32.const 0)))
+    (local.set 0x39e (i64.load offset=0x39e align=1 (i32.const 0)))
+    (local.set 0x39f (i64.load offset=0x39f align=1 (i32.const 0)))
+    (local.set 0x3a0 (i64.load offset=0x3a0 align=1 (i32.const 0)))
+    (local.set 0x3a1 (i64.load offset=0x3a1 align=1 (i32.const 0)))
+    (local.set 0x3a2 (i64.load offset=0x3a2 align=1 (i32.const 0)))
+    (local.set 0x3a3 (i64.load offset=0x3a3 align=1 (i32.const 0)))
+    (local.set 0x3a4 (i64.load offset=0x3a4 align=1 (i32.const 0)))
+    (local.set 0x3a5 (i64.load offset=0x3a5 align=1 (i32.const 0)))
+    (local.set 0x3a6 (i64.load offset=0x3a6 align=1 (i32.const 0)))
+    (local.set 0x3a7 (i64.load offset=0x3a7 align=1 (i32.const 0)))
+    (local.set 0x3a8 (i64.load offset=0x3a8 align=1 (i32.const 0)))
+    (local.set 0x3a9 (i64.load offset=0x3a9 align=1 (i32.const 0)))
+    (local.set 0x3aa (i64.load offset=0x3aa align=1 (i32.const 0)))
+    (local.set 0x3ab (i64.load offset=0x3ab align=1 (i32.const 0)))
+    (local.set 0x3ac (i64.load offset=0x3ac align=1 (i32.const 0)))
+    (local.set 0x3ad (i64.load offset=0x3ad align=1 (i32.const 0)))
+    (local.set 0x3ae (i64.load offset=0x3ae align=1 (i32.const 0)))
+    (local.set 0x3af (i64.load offset=0x3af align=1 (i32.const 0)))
+    (local.set 0x3b0 (i64.load offset=0x3b0 align=1 (i32.const 0)))
+    (local.set 0x3b1 (i64.load offset=0x3b1 align=1 (i32.const 0)))
+    (local.set 0x3b2 (i64.load offset=0x3b2 align=1 (i32.const 0)))
+    (local.set 0x3b3 (i64.load offset=0x3b3 align=1 (i32.const 0)))
+    (local.set 0x3b4 (i64.load offset=0x3b4 align=1 (i32.const 0)))
+    (local.set 0x3b5 (i64.load offset=0x3b5 align=1 (i32.const 0)))
+    (local.set 0x3b6 (i64.load offset=0x3b6 align=1 (i32.const 0)))
+    (local.set 0x3b7 (i64.load offset=0x3b7 align=1 (i32.const 0)))
+    (local.set 0x3b8 (i64.load offset=0x3b8 align=1 (i32.const 0)))
+    (local.set 0x3b9 (i64.load offset=0x3b9 align=1 (i32.const 0)))
+    (local.set 0x3ba (i64.load offset=0x3ba align=1 (i32.const 0)))
+    (local.set 0x3bb (i64.load offset=0x3bb align=1 (i32.const 0)))
+    (local.set 0x3bc (i64.load offset=0x3bc align=1 (i32.const 0)))
+    (local.set 0x3bd (i64.load offset=0x3bd align=1 (i32.const 0)))
+    (local.set 0x3be (i64.load offset=0x3be align=1 (i32.const 0)))
+    (local.set 0x3bf (i64.load offset=0x3bf align=1 (i32.const 0)))
+    (local.set 0x3c0 (i64.load offset=0x3c0 align=1 (i32.const 0)))
+    (local.set 0x3c1 (i64.load offset=0x3c1 align=1 (i32.const 0)))
+    (local.set 0x3c2 (i64.load offset=0x3c2 align=1 (i32.const 0)))
+    (local.set 0x3c3 (i64.load offset=0x3c3 align=1 (i32.const 0)))
+    (local.set 0x3c4 (i64.load offset=0x3c4 align=1 (i32.const 0)))
+    (local.set 0x3c5 (i64.load offset=0x3c5 align=1 (i32.const 0)))
+    (local.set 0x3c6 (i64.load offset=0x3c6 align=1 (i32.const 0)))
+    (local.set 0x3c7 (i64.load offset=0x3c7 align=1 (i32.const 0)))
+    (local.set 0x3c8 (i64.load offset=0x3c8 align=1 (i32.const 0)))
+    (local.set 0x3c9 (i64.load offset=0x3c9 align=1 (i32.const 0)))
+    (local.set 0x3ca (i64.load offset=0x3ca align=1 (i32.const 0)))
+    (local.set 0x3cb (i64.load offset=0x3cb align=1 (i32.const 0)))
+    (local.set 0x3cc (i64.load offset=0x3cc align=1 (i32.const 0)))
+    (local.set 0x3cd (i64.load offset=0x3cd align=1 (i32.const 0)))
+    (local.set 0x3ce (i64.load offset=0x3ce align=1 (i32.const 0)))
+    (local.set 0x3cf (i64.load offset=0x3cf align=1 (i32.const 0)))
+    (local.set 0x3d0 (i64.load offset=0x3d0 align=1 (i32.const 0)))
+    (local.set 0x3d1 (i64.load offset=0x3d1 align=1 (i32.const 0)))
+    (local.set 0x3d2 (i64.load offset=0x3d2 align=1 (i32.const 0)))
+    (local.set 0x3d3 (i64.load offset=0x3d3 align=1 (i32.const 0)))
+    (local.set 0x3d4 (i64.load offset=0x3d4 align=1 (i32.const 0)))
+    (local.set 0x3d5 (i64.load offset=0x3d5 align=1 (i32.const 0)))
+    (local.set 0x3d6 (i64.load offset=0x3d6 align=1 (i32.const 0)))
+    (local.set 0x3d7 (i64.load offset=0x3d7 align=1 (i32.const 0)))
+    (local.set 0x3d8 (i64.load offset=0x3d8 align=1 (i32.const 0)))
+    (local.set 0x3d9 (i64.load offset=0x3d9 align=1 (i32.const 0)))
+    (local.set 0x3da (i64.load offset=0x3da align=1 (i32.const 0)))
+    (local.set 0x3db (i64.load offset=0x3db align=1 (i32.const 0)))
+    (local.set 0x3dc (i64.load offset=0x3dc align=1 (i32.const 0)))
+    (local.set 0x3dd (i64.load offset=0x3dd align=1 (i32.const 0)))
+    (local.set 0x3de (i64.load offset=0x3de align=1 (i32.const 0)))
+    (local.set 0x3df (i64.load offset=0x3df align=1 (i32.const 0)))
+    (local.set 0x3e0 (i64.load offset=0x3e0 align=1 (i32.const 0)))
+    (local.set 0x3e1 (i64.load offset=0x3e1 align=1 (i32.const 0)))
+    (local.set 0x3e2 (i64.load offset=0x3e2 align=1 (i32.const 0)))
+    (local.set 0x3e3 (i64.load offset=0x3e3 align=1 (i32.const 0)))
+    (local.set 0x3e4 (i64.load offset=0x3e4 align=1 (i32.const 0)))
+    (local.set 0x3e5 (i64.load offset=0x3e5 align=1 (i32.const 0)))
+    (local.set 0x3e6 (i64.load offset=0x3e6 align=1 (i32.const 0)))
+    (local.set 0x3e7 (i64.load offset=0x3e7 align=1 (i32.const 0)))
+    (local.set 0x3e8 (i64.load offset=0x3e8 align=1 (i32.const 0)))
+    (local.set 0x3e9 (i64.load offset=0x3e9 align=1 (i32.const 0)))
+    (local.set 0x3ea (i64.load offset=0x3ea align=1 (i32.const 0)))
+    (local.set 0x3eb (i64.load offset=0x3eb align=1 (i32.const 0)))
+    (local.set 0x3ec (i64.load offset=0x3ec align=1 (i32.const 0)))
+    (local.set 0x3ed (i64.load offset=0x3ed align=1 (i32.const 0)))
+    (local.set 0x3ee (i64.load offset=0x3ee align=1 (i32.const 0)))
+    (local.set 0x3ef (i64.load offset=0x3ef align=1 (i32.const 0)))
+    (local.set 0x3f0 (i64.load offset=0x3f0 align=1 (i32.const 0)))
+    (local.set 0x3f1 (i64.load offset=0x3f1 align=1 (i32.const 0)))
+    (local.set 0x3f2 (i64.load offset=0x3f2 align=1 (i32.const 0)))
+    (local.set 0x3f3 (i64.load offset=0x3f3 align=1 (i32.const 0)))
+    (local.set 0x3f4 (i64.load offset=0x3f4 align=1 (i32.const 0)))
+    (local.set 0x3f5 (i64.load offset=0x3f5 align=1 (i32.const 0)))
+    (local.set 0x3f6 (i64.load offset=0x3f6 align=1 (i32.const 0)))
+    (local.set 0x3f7 (i64.load offset=0x3f7 align=1 (i32.const 0)))
+    (local.set 0x3f8 (i64.load offset=0x3f8 align=1 (i32.const 0)))
+    (local.set 0x3f9 (i64.load offset=0x3f9 align=1 (i32.const 0)))
+    (local.set 0x3fa (i64.load offset=0x3fa align=1 (i32.const 0)))
+    (local.set 0x3fb (i64.load offset=0x3fb align=1 (i32.const 0)))
+    (local.set 0x3fc (i64.load offset=0x3fc align=1 (i32.const 0)))
+    (local.set 0x3fd (i64.load offset=0x3fd align=1 (i32.const 0)))
+    (local.set 0x3fe (i64.load offset=0x3fe align=1 (i32.const 0)))
+    (local.set 0x3ff (i64.load offset=0x3ff align=1 (i32.const 0)))
+    (local.set 0x400 (i64.load offset=0x400 align=1 (i32.const 0)))
+    (local.set 0x401 (i64.load offset=0x401 align=1 (i32.const 0)))
+    (local.set 0x402 (i64.load offset=0x402 align=1 (i32.const 0)))
+    (local.set 0x403 (i64.load offset=0x403 align=1 (i32.const 0)))
+    (local.set 0x404 (i64.load offset=0x404 align=1 (i32.const 0)))
+    (local.set 0x405 (i64.load offset=0x405 align=1 (i32.const 0)))
+    (local.set 0x406 (i64.load offset=0x406 align=1 (i32.const 0)))
+    (local.set 0x407 (i64.load offset=0x407 align=1 (i32.const 0)))
+    (local.set 0x408 (i64.load offset=0x408 align=1 (i32.const 0)))
+    (local.set 0x409 (i64.load offset=0x409 align=1 (i32.const 0)))
+    (local.set 0x40a (i64.load offset=0x40a align=1 (i32.const 0)))
+    (local.set 0x40b (i64.load offset=0x40b align=1 (i32.const 0)))
+    (local.set 0x40c (i64.load offset=0x40c align=1 (i32.const 0)))
+    (local.set 0x40d (i64.load offset=0x40d align=1 (i32.const 0)))
+    (local.set 0x40e (i64.load offset=0x40e align=1 (i32.const 0)))
+    (local.set 0x40f (i64.load offset=0x40f align=1 (i32.const 0)))
+    (local.set 0x410 (i64.load offset=0x410 align=1 (i32.const 0)))
+    (local.set 0x411 (i64.load offset=0x411 align=1 (i32.const 0)))
+    (local.set 0x412 (i64.load offset=0x412 align=1 (i32.const 0)))
+    (local.set 0x413 (i64.load offset=0x413 align=1 (i32.const 0)))
+    (local.set 0x414 (i64.load offset=0x414 align=1 (i32.const 0)))
+    (local.set 0x415 (i64.load offset=0x415 align=1 (i32.const 0)))
+    (local.set 0x416 (i64.load offset=0x416 align=1 (i32.const 0)))
+    (local.set 0x417 (i64.load offset=0x417 align=1 (i32.const 0)))
+    (local.set 0x418 (i64.load offset=0x418 align=1 (i32.const 0)))
+    (local.set 0x419 (i64.load offset=0x419 align=1 (i32.const 0)))
+    (local.set 0x41a (i64.load offset=0x41a align=1 (i32.const 0)))
+    (local.set 0x41b (i64.load offset=0x41b align=1 (i32.const 0)))
+    (local.set 0x41c (i64.load offset=0x41c align=1 (i32.const 0)))
+    (local.set 0x41d (i64.load offset=0x41d align=1 (i32.const 0)))
+    (local.set 0x41e (i64.load offset=0x41e align=1 (i32.const 0)))
+    (local.set 0x41f (i64.load offset=0x41f align=1 (i32.const 0)))
+
+    ;; store the locals back to memory
+    (i64.store offset=0x000 align=1 (i32.const 0) (local.get 0x000))
+    (i64.store offset=0x001 align=1 (i32.const 0) (local.get 0x001))
+    (i64.store offset=0x002 align=1 (i32.const 0) (local.get 0x002))
+    (i64.store offset=0x003 align=1 (i32.const 0) (local.get 0x003))
+    (i64.store offset=0x004 align=1 (i32.const 0) (local.get 0x004))
+    (i64.store offset=0x005 align=1 (i32.const 0) (local.get 0x005))
+    (i64.store offset=0x006 align=1 (i32.const 0) (local.get 0x006))
+    (i64.store offset=0x007 align=1 (i32.const 0) (local.get 0x007))
+    (i64.store offset=0x008 align=1 (i32.const 0) (local.get 0x008))
+    (i64.store offset=0x009 align=1 (i32.const 0) (local.get 0x009))
+    (i64.store offset=0x00a align=1 (i32.const 0) (local.get 0x00a))
+    (i64.store offset=0x00b align=1 (i32.const 0) (local.get 0x00b))
+    (i64.store offset=0x00c align=1 (i32.const 0) (local.get 0x00c))
+    (i64.store offset=0x00d align=1 (i32.const 0) (local.get 0x00d))
+    (i64.store offset=0x00e align=1 (i32.const 0) (local.get 0x00e))
+    (i64.store offset=0x00f align=1 (i32.const 0) (local.get 0x00f))
+    (i64.store offset=0x010 align=1 (i32.const 0) (local.get 0x010))
+    (i64.store offset=0x011 align=1 (i32.const 0) (local.get 0x011))
+    (i64.store offset=0x012 align=1 (i32.const 0) (local.get 0x012))
+    (i64.store offset=0x013 align=1 (i32.const 0) (local.get 0x013))
+    (i64.store offset=0x014 align=1 (i32.const 0) (local.get 0x014))
+    (i64.store offset=0x015 align=1 (i32.const 0) (local.get 0x015))
+    (i64.store offset=0x016 align=1 (i32.const 0) (local.get 0x016))
+    (i64.store offset=0x017 align=1 (i32.const 0) (local.get 0x017))
+    (i64.store offset=0x018 align=1 (i32.const 0) (local.get 0x018))
+    (i64.store offset=0x019 align=1 (i32.const 0) (local.get 0x019))
+    (i64.store offset=0x01a align=1 (i32.const 0) (local.get 0x01a))
+    (i64.store offset=0x01b align=1 (i32.const 0) (local.get 0x01b))
+    (i64.store offset=0x01c align=1 (i32.const 0) (local.get 0x01c))
+    (i64.store offset=0x01d align=1 (i32.const 0) (local.get 0x01d))
+    (i64.store offset=0x01e align=1 (i32.const 0) (local.get 0x01e))
+    (i64.store offset=0x01f align=1 (i32.const 0) (local.get 0x01f))
+    (i64.store offset=0x020 align=1 (i32.const 0) (local.get 0x020))
+    (i64.store offset=0x021 align=1 (i32.const 0) (local.get 0x021))
+    (i64.store offset=0x022 align=1 (i32.const 0) (local.get 0x022))
+    (i64.store offset=0x023 align=1 (i32.const 0) (local.get 0x023))
+    (i64.store offset=0x024 align=1 (i32.const 0) (local.get 0x024))
+    (i64.store offset=0x025 align=1 (i32.const 0) (local.get 0x025))
+    (i64.store offset=0x026 align=1 (i32.const 0) (local.get 0x026))
+    (i64.store offset=0x027 align=1 (i32.const 0) (local.get 0x027))
+    (i64.store offset=0x028 align=1 (i32.const 0) (local.get 0x028))
+    (i64.store offset=0x029 align=1 (i32.const 0) (local.get 0x029))
+    (i64.store offset=0x02a align=1 (i32.const 0) (local.get 0x02a))
+    (i64.store offset=0x02b align=1 (i32.const 0) (local.get 0x02b))
+    (i64.store offset=0x02c align=1 (i32.const 0) (local.get 0x02c))
+    (i64.store offset=0x02d align=1 (i32.const 0) (local.get 0x02d))
+    (i64.store offset=0x02e align=1 (i32.const 0) (local.get 0x02e))
+    (i64.store offset=0x02f align=1 (i32.const 0) (local.get 0x02f))
+    (i64.store offset=0x030 align=1 (i32.const 0) (local.get 0x030))
+    (i64.store offset=0x031 align=1 (i32.const 0) (local.get 0x031))
+    (i64.store offset=0x032 align=1 (i32.const 0) (local.get 0x032))
+    (i64.store offset=0x033 align=1 (i32.const 0) (local.get 0x033))
+    (i64.store offset=0x034 align=1 (i32.const 0) (local.get 0x034))
+    (i64.store offset=0x035 align=1 (i32.const 0) (local.get 0x035))
+    (i64.store offset=0x036 align=1 (i32.const 0) (local.get 0x036))
+    (i64.store offset=0x037 align=1 (i32.const 0) (local.get 0x037))
+    (i64.store offset=0x038 align=1 (i32.const 0) (local.get 0x038))
+    (i64.store offset=0x039 align=1 (i32.const 0) (local.get 0x039))
+    (i64.store offset=0x03a align=1 (i32.const 0) (local.get 0x03a))
+    (i64.store offset=0x03b align=1 (i32.const 0) (local.get 0x03b))
+    (i64.store offset=0x03c align=1 (i32.const 0) (local.get 0x03c))
+    (i64.store offset=0x03d align=1 (i32.const 0) (local.get 0x03d))
+    (i64.store offset=0x03e align=1 (i32.const 0) (local.get 0x03e))
+    (i64.store offset=0x03f align=1 (i32.const 0) (local.get 0x03f))
+    (i64.store offset=0x040 align=1 (i32.const 0) (local.get 0x040))
+    (i64.store offset=0x041 align=1 (i32.const 0) (local.get 0x041))
+    (i64.store offset=0x042 align=1 (i32.const 0) (local.get 0x042))
+    (i64.store offset=0x043 align=1 (i32.const 0) (local.get 0x043))
+    (i64.store offset=0x044 align=1 (i32.const 0) (local.get 0x044))
+    (i64.store offset=0x045 align=1 (i32.const 0) (local.get 0x045))
+    (i64.store offset=0x046 align=1 (i32.const 0) (local.get 0x046))
+    (i64.store offset=0x047 align=1 (i32.const 0) (local.get 0x047))
+    (i64.store offset=0x048 align=1 (i32.const 0) (local.get 0x048))
+    (i64.store offset=0x049 align=1 (i32.const 0) (local.get 0x049))
+    (i64.store offset=0x04a align=1 (i32.const 0) (local.get 0x04a))
+    (i64.store offset=0x04b align=1 (i32.const 0) (local.get 0x04b))
+    (i64.store offset=0x04c align=1 (i32.const 0) (local.get 0x04c))
+    (i64.store offset=0x04d align=1 (i32.const 0) (local.get 0x04d))
+    (i64.store offset=0x04e align=1 (i32.const 0) (local.get 0x04e))
+    (i64.store offset=0x04f align=1 (i32.const 0) (local.get 0x04f))
+    (i64.store offset=0x050 align=1 (i32.const 0) (local.get 0x050))
+    (i64.store offset=0x051 align=1 (i32.const 0) (local.get 0x051))
+    (i64.store offset=0x052 align=1 (i32.const 0) (local.get 0x052))
+    (i64.store offset=0x053 align=1 (i32.const 0) (local.get 0x053))
+    (i64.store offset=0x054 align=1 (i32.const 0) (local.get 0x054))
+    (i64.store offset=0x055 align=1 (i32.const 0) (local.get 0x055))
+    (i64.store offset=0x056 align=1 (i32.const 0) (local.get 0x056))
+    (i64.store offset=0x057 align=1 (i32.const 0) (local.get 0x057))
+    (i64.store offset=0x058 align=1 (i32.const 0) (local.get 0x058))
+    (i64.store offset=0x059 align=1 (i32.const 0) (local.get 0x059))
+    (i64.store offset=0x05a align=1 (i32.const 0) (local.get 0x05a))
+    (i64.store offset=0x05b align=1 (i32.const 0) (local.get 0x05b))
+    (i64.store offset=0x05c align=1 (i32.const 0) (local.get 0x05c))
+    (i64.store offset=0x05d align=1 (i32.const 0) (local.get 0x05d))
+    (i64.store offset=0x05e align=1 (i32.const 0) (local.get 0x05e))
+    (i64.store offset=0x05f align=1 (i32.const 0) (local.get 0x05f))
+    (i64.store offset=0x060 align=1 (i32.const 0) (local.get 0x060))
+    (i64.store offset=0x061 align=1 (i32.const 0) (local.get 0x061))
+    (i64.store offset=0x062 align=1 (i32.const 0) (local.get 0x062))
+    (i64.store offset=0x063 align=1 (i32.const 0) (local.get 0x063))
+    (i64.store offset=0x064 align=1 (i32.const 0) (local.get 0x064))
+    (i64.store offset=0x065 align=1 (i32.const 0) (local.get 0x065))
+    (i64.store offset=0x066 align=1 (i32.const 0) (local.get 0x066))
+    (i64.store offset=0x067 align=1 (i32.const 0) (local.get 0x067))
+    (i64.store offset=0x068 align=1 (i32.const 0) (local.get 0x068))
+    (i64.store offset=0x069 align=1 (i32.const 0) (local.get 0x069))
+    (i64.store offset=0x06a align=1 (i32.const 0) (local.get 0x06a))
+    (i64.store offset=0x06b align=1 (i32.const 0) (local.get 0x06b))
+    (i64.store offset=0x06c align=1 (i32.const 0) (local.get 0x06c))
+    (i64.store offset=0x06d align=1 (i32.const 0) (local.get 0x06d))
+    (i64.store offset=0x06e align=1 (i32.const 0) (local.get 0x06e))
+    (i64.store offset=0x06f align=1 (i32.const 0) (local.get 0x06f))
+    (i64.store offset=0x070 align=1 (i32.const 0) (local.get 0x070))
+    (i64.store offset=0x071 align=1 (i32.const 0) (local.get 0x071))
+    (i64.store offset=0x072 align=1 (i32.const 0) (local.get 0x072))
+    (i64.store offset=0x073 align=1 (i32.const 0) (local.get 0x073))
+    (i64.store offset=0x074 align=1 (i32.const 0) (local.get 0x074))
+    (i64.store offset=0x075 align=1 (i32.const 0) (local.get 0x075))
+    (i64.store offset=0x076 align=1 (i32.const 0) (local.get 0x076))
+    (i64.store offset=0x077 align=1 (i32.const 0) (local.get 0x077))
+    (i64.store offset=0x078 align=1 (i32.const 0) (local.get 0x078))
+    (i64.store offset=0x079 align=1 (i32.const 0) (local.get 0x079))
+    (i64.store offset=0x07a align=1 (i32.const 0) (local.get 0x07a))
+    (i64.store offset=0x07b align=1 (i32.const 0) (local.get 0x07b))
+    (i64.store offset=0x07c align=1 (i32.const 0) (local.get 0x07c))
+    (i64.store offset=0x07d align=1 (i32.const 0) (local.get 0x07d))
+    (i64.store offset=0x07e align=1 (i32.const 0) (local.get 0x07e))
+    (i64.store offset=0x07f align=1 (i32.const 0) (local.get 0x07f))
+    (i64.store offset=0x080 align=1 (i32.const 0) (local.get 0x080))
+    (i64.store offset=0x081 align=1 (i32.const 0) (local.get 0x081))
+    (i64.store offset=0x082 align=1 (i32.const 0) (local.get 0x082))
+    (i64.store offset=0x083 align=1 (i32.const 0) (local.get 0x083))
+    (i64.store offset=0x084 align=1 (i32.const 0) (local.get 0x084))
+    (i64.store offset=0x085 align=1 (i32.const 0) (local.get 0x085))
+    (i64.store offset=0x086 align=1 (i32.const 0) (local.get 0x086))
+    (i64.store offset=0x087 align=1 (i32.const 0) (local.get 0x087))
+    (i64.store offset=0x088 align=1 (i32.const 0) (local.get 0x088))
+    (i64.store offset=0x089 align=1 (i32.const 0) (local.get 0x089))
+    (i64.store offset=0x08a align=1 (i32.const 0) (local.get 0x08a))
+    (i64.store offset=0x08b align=1 (i32.const 0) (local.get 0x08b))
+    (i64.store offset=0x08c align=1 (i32.const 0) (local.get 0x08c))
+    (i64.store offset=0x08d align=1 (i32.const 0) (local.get 0x08d))
+    (i64.store offset=0x08e align=1 (i32.const 0) (local.get 0x08e))
+    (i64.store offset=0x08f align=1 (i32.const 0) (local.get 0x08f))
+    (i64.store offset=0x090 align=1 (i32.const 0) (local.get 0x090))
+    (i64.store offset=0x091 align=1 (i32.const 0) (local.get 0x091))
+    (i64.store offset=0x092 align=1 (i32.const 0) (local.get 0x092))
+    (i64.store offset=0x093 align=1 (i32.const 0) (local.get 0x093))
+    (i64.store offset=0x094 align=1 (i32.const 0) (local.get 0x094))
+    (i64.store offset=0x095 align=1 (i32.const 0) (local.get 0x095))
+    (i64.store offset=0x096 align=1 (i32.const 0) (local.get 0x096))
+    (i64.store offset=0x097 align=1 (i32.const 0) (local.get 0x097))
+    (i64.store offset=0x098 align=1 (i32.const 0) (local.get 0x098))
+    (i64.store offset=0x099 align=1 (i32.const 0) (local.get 0x099))
+    (i64.store offset=0x09a align=1 (i32.const 0) (local.get 0x09a))
+    (i64.store offset=0x09b align=1 (i32.const 0) (local.get 0x09b))
+    (i64.store offset=0x09c align=1 (i32.const 0) (local.get 0x09c))
+    (i64.store offset=0x09d align=1 (i32.const 0) (local.get 0x09d))
+    (i64.store offset=0x09e align=1 (i32.const 0) (local.get 0x09e))
+    (i64.store offset=0x09f align=1 (i32.const 0) (local.get 0x09f))
+    (i64.store offset=0x0a0 align=1 (i32.const 0) (local.get 0x0a0))
+    (i64.store offset=0x0a1 align=1 (i32.const 0) (local.get 0x0a1))
+    (i64.store offset=0x0a2 align=1 (i32.const 0) (local.get 0x0a2))
+    (i64.store offset=0x0a3 align=1 (i32.const 0) (local.get 0x0a3))
+    (i64.store offset=0x0a4 align=1 (i32.const 0) (local.get 0x0a4))
+    (i64.store offset=0x0a5 align=1 (i32.const 0) (local.get 0x0a5))
+    (i64.store offset=0x0a6 align=1 (i32.const 0) (local.get 0x0a6))
+    (i64.store offset=0x0a7 align=1 (i32.const 0) (local.get 0x0a7))
+    (i64.store offset=0x0a8 align=1 (i32.const 0) (local.get 0x0a8))
+    (i64.store offset=0x0a9 align=1 (i32.const 0) (local.get 0x0a9))
+    (i64.store offset=0x0aa align=1 (i32.const 0) (local.get 0x0aa))
+    (i64.store offset=0x0ab align=1 (i32.const 0) (local.get 0x0ab))
+    (i64.store offset=0x0ac align=1 (i32.const 0) (local.get 0x0ac))
+    (i64.store offset=0x0ad align=1 (i32.const 0) (local.get 0x0ad))
+    (i64.store offset=0x0ae align=1 (i32.const 0) (local.get 0x0ae))
+    (i64.store offset=0x0af align=1 (i32.const 0) (local.get 0x0af))
+    (i64.store offset=0x0b0 align=1 (i32.const 0) (local.get 0x0b0))
+    (i64.store offset=0x0b1 align=1 (i32.const 0) (local.get 0x0b1))
+    (i64.store offset=0x0b2 align=1 (i32.const 0) (local.get 0x0b2))
+    (i64.store offset=0x0b3 align=1 (i32.const 0) (local.get 0x0b3))
+    (i64.store offset=0x0b4 align=1 (i32.const 0) (local.get 0x0b4))
+    (i64.store offset=0x0b5 align=1 (i32.const 0) (local.get 0x0b5))
+    (i64.store offset=0x0b6 align=1 (i32.const 0) (local.get 0x0b6))
+    (i64.store offset=0x0b7 align=1 (i32.const 0) (local.get 0x0b7))
+    (i64.store offset=0x0b8 align=1 (i32.const 0) (local.get 0x0b8))
+    (i64.store offset=0x0b9 align=1 (i32.const 0) (local.get 0x0b9))
+    (i64.store offset=0x0ba align=1 (i32.const 0) (local.get 0x0ba))
+    (i64.store offset=0x0bb align=1 (i32.const 0) (local.get 0x0bb))
+    (i64.store offset=0x0bc align=1 (i32.const 0) (local.get 0x0bc))
+    (i64.store offset=0x0bd align=1 (i32.const 0) (local.get 0x0bd))
+    (i64.store offset=0x0be align=1 (i32.const 0) (local.get 0x0be))
+    (i64.store offset=0x0bf align=1 (i32.const 0) (local.get 0x0bf))
+    (i64.store offset=0x0c0 align=1 (i32.const 0) (local.get 0x0c0))
+    (i64.store offset=0x0c1 align=1 (i32.const 0) (local.get 0x0c1))
+    (i64.store offset=0x0c2 align=1 (i32.const 0) (local.get 0x0c2))
+    (i64.store offset=0x0c3 align=1 (i32.const 0) (local.get 0x0c3))
+    (i64.store offset=0x0c4 align=1 (i32.const 0) (local.get 0x0c4))
+    (i64.store offset=0x0c5 align=1 (i32.const 0) (local.get 0x0c5))
+    (i64.store offset=0x0c6 align=1 (i32.const 0) (local.get 0x0c6))
+    (i64.store offset=0x0c7 align=1 (i32.const 0) (local.get 0x0c7))
+    (i64.store offset=0x0c8 align=1 (i32.const 0) (local.get 0x0c8))
+    (i64.store offset=0x0c9 align=1 (i32.const 0) (local.get 0x0c9))
+    (i64.store offset=0x0ca align=1 (i32.const 0) (local.get 0x0ca))
+    (i64.store offset=0x0cb align=1 (i32.const 0) (local.get 0x0cb))
+    (i64.store offset=0x0cc align=1 (i32.const 0) (local.get 0x0cc))
+    (i64.store offset=0x0cd align=1 (i32.const 0) (local.get 0x0cd))
+    (i64.store offset=0x0ce align=1 (i32.const 0) (local.get 0x0ce))
+    (i64.store offset=0x0cf align=1 (i32.const 0) (local.get 0x0cf))
+    (i64.store offset=0x0d0 align=1 (i32.const 0) (local.get 0x0d0))
+    (i64.store offset=0x0d1 align=1 (i32.const 0) (local.get 0x0d1))
+    (i64.store offset=0x0d2 align=1 (i32.const 0) (local.get 0x0d2))
+    (i64.store offset=0x0d3 align=1 (i32.const 0) (local.get 0x0d3))
+    (i64.store offset=0x0d4 align=1 (i32.const 0) (local.get 0x0d4))
+    (i64.store offset=0x0d5 align=1 (i32.const 0) (local.get 0x0d5))
+    (i64.store offset=0x0d6 align=1 (i32.const 0) (local.get 0x0d6))
+    (i64.store offset=0x0d7 align=1 (i32.const 0) (local.get 0x0d7))
+    (i64.store offset=0x0d8 align=1 (i32.const 0) (local.get 0x0d8))
+    (i64.store offset=0x0d9 align=1 (i32.const 0) (local.get 0x0d9))
+    (i64.store offset=0x0da align=1 (i32.const 0) (local.get 0x0da))
+    (i64.store offset=0x0db align=1 (i32.const 0) (local.get 0x0db))
+    (i64.store offset=0x0dc align=1 (i32.const 0) (local.get 0x0dc))
+    (i64.store offset=0x0dd align=1 (i32.const 0) (local.get 0x0dd))
+    (i64.store offset=0x0de align=1 (i32.const 0) (local.get 0x0de))
+    (i64.store offset=0x0df align=1 (i32.const 0) (local.get 0x0df))
+    (i64.store offset=0x0e0 align=1 (i32.const 0) (local.get 0x0e0))
+    (i64.store offset=0x0e1 align=1 (i32.const 0) (local.get 0x0e1))
+    (i64.store offset=0x0e2 align=1 (i32.const 0) (local.get 0x0e2))
+    (i64.store offset=0x0e3 align=1 (i32.const 0) (local.get 0x0e3))
+    (i64.store offset=0x0e4 align=1 (i32.const 0) (local.get 0x0e4))
+    (i64.store offset=0x0e5 align=1 (i32.const 0) (local.get 0x0e5))
+    (i64.store offset=0x0e6 align=1 (i32.const 0) (local.get 0x0e6))
+    (i64.store offset=0x0e7 align=1 (i32.const 0) (local.get 0x0e7))
+    (i64.store offset=0x0e8 align=1 (i32.const 0) (local.get 0x0e8))
+    (i64.store offset=0x0e9 align=1 (i32.const 0) (local.get 0x0e9))
+    (i64.store offset=0x0ea align=1 (i32.const 0) (local.get 0x0ea))
+    (i64.store offset=0x0eb align=1 (i32.const 0) (local.get 0x0eb))
+    (i64.store offset=0x0ec align=1 (i32.const 0) (local.get 0x0ec))
+    (i64.store offset=0x0ed align=1 (i32.const 0) (local.get 0x0ed))
+    (i64.store offset=0x0ee align=1 (i32.const 0) (local.get 0x0ee))
+    (i64.store offset=0x0ef align=1 (i32.const 0) (local.get 0x0ef))
+    (i64.store offset=0x0f0 align=1 (i32.const 0) (local.get 0x0f0))
+    (i64.store offset=0x0f1 align=1 (i32.const 0) (local.get 0x0f1))
+    (i64.store offset=0x0f2 align=1 (i32.const 0) (local.get 0x0f2))
+    (i64.store offset=0x0f3 align=1 (i32.const 0) (local.get 0x0f3))
+    (i64.store offset=0x0f4 align=1 (i32.const 0) (local.get 0x0f4))
+    (i64.store offset=0x0f5 align=1 (i32.const 0) (local.get 0x0f5))
+    (i64.store offset=0x0f6 align=1 (i32.const 0) (local.get 0x0f6))
+    (i64.store offset=0x0f7 align=1 (i32.const 0) (local.get 0x0f7))
+    (i64.store offset=0x0f8 align=1 (i32.const 0) (local.get 0x0f8))
+    (i64.store offset=0x0f9 align=1 (i32.const 0) (local.get 0x0f9))
+    (i64.store offset=0x0fa align=1 (i32.const 0) (local.get 0x0fa))
+    (i64.store offset=0x0fb align=1 (i32.const 0) (local.get 0x0fb))
+    (i64.store offset=0x0fc align=1 (i32.const 0) (local.get 0x0fc))
+    (i64.store offset=0x0fd align=1 (i32.const 0) (local.get 0x0fd))
+    (i64.store offset=0x0fe align=1 (i32.const 0) (local.get 0x0fe))
+    (i64.store offset=0x0ff align=1 (i32.const 0) (local.get 0x0ff))
+    (i64.store offset=0x100 align=1 (i32.const 0) (local.get 0x100))
+    (i64.store offset=0x101 align=1 (i32.const 0) (local.get 0x101))
+    (i64.store offset=0x102 align=1 (i32.const 0) (local.get 0x102))
+    (i64.store offset=0x103 align=1 (i32.const 0) (local.get 0x103))
+    (i64.store offset=0x104 align=1 (i32.const 0) (local.get 0x104))
+    (i64.store offset=0x105 align=1 (i32.const 0) (local.get 0x105))
+    (i64.store offset=0x106 align=1 (i32.const 0) (local.get 0x106))
+    (i64.store offset=0x107 align=1 (i32.const 0) (local.get 0x107))
+    (i64.store offset=0x108 align=1 (i32.const 0) (local.get 0x108))
+    (i64.store offset=0x109 align=1 (i32.const 0) (local.get 0x109))
+    (i64.store offset=0x10a align=1 (i32.const 0) (local.get 0x10a))
+    (i64.store offset=0x10b align=1 (i32.const 0) (local.get 0x10b))
+    (i64.store offset=0x10c align=1 (i32.const 0) (local.get 0x10c))
+    (i64.store offset=0x10d align=1 (i32.const 0) (local.get 0x10d))
+    (i64.store offset=0x10e align=1 (i32.const 0) (local.get 0x10e))
+    (i64.store offset=0x10f align=1 (i32.const 0) (local.get 0x10f))
+    (i64.store offset=0x110 align=1 (i32.const 0) (local.get 0x110))
+    (i64.store offset=0x111 align=1 (i32.const 0) (local.get 0x111))
+    (i64.store offset=0x112 align=1 (i32.const 0) (local.get 0x112))
+    (i64.store offset=0x113 align=1 (i32.const 0) (local.get 0x113))
+    (i64.store offset=0x114 align=1 (i32.const 0) (local.get 0x114))
+    (i64.store offset=0x115 align=1 (i32.const 0) (local.get 0x115))
+    (i64.store offset=0x116 align=1 (i32.const 0) (local.get 0x116))
+    (i64.store offset=0x117 align=1 (i32.const 0) (local.get 0x117))
+    (i64.store offset=0x118 align=1 (i32.const 0) (local.get 0x118))
+    (i64.store offset=0x119 align=1 (i32.const 0) (local.get 0x119))
+    (i64.store offset=0x11a align=1 (i32.const 0) (local.get 0x11a))
+    (i64.store offset=0x11b align=1 (i32.const 0) (local.get 0x11b))
+    (i64.store offset=0x11c align=1 (i32.const 0) (local.get 0x11c))
+    (i64.store offset=0x11d align=1 (i32.const 0) (local.get 0x11d))
+    (i64.store offset=0x11e align=1 (i32.const 0) (local.get 0x11e))
+    (i64.store offset=0x11f align=1 (i32.const 0) (local.get 0x11f))
+    (i64.store offset=0x120 align=1 (i32.const 0) (local.get 0x120))
+    (i64.store offset=0x121 align=1 (i32.const 0) (local.get 0x121))
+    (i64.store offset=0x122 align=1 (i32.const 0) (local.get 0x122))
+    (i64.store offset=0x123 align=1 (i32.const 0) (local.get 0x123))
+    (i64.store offset=0x124 align=1 (i32.const 0) (local.get 0x124))
+    (i64.store offset=0x125 align=1 (i32.const 0) (local.get 0x125))
+    (i64.store offset=0x126 align=1 (i32.const 0) (local.get 0x126))
+    (i64.store offset=0x127 align=1 (i32.const 0) (local.get 0x127))
+    (i64.store offset=0x128 align=1 (i32.const 0) (local.get 0x128))
+    (i64.store offset=0x129 align=1 (i32.const 0) (local.get 0x129))
+    (i64.store offset=0x12a align=1 (i32.const 0) (local.get 0x12a))
+    (i64.store offset=0x12b align=1 (i32.const 0) (local.get 0x12b))
+    (i64.store offset=0x12c align=1 (i32.const 0) (local.get 0x12c))
+    (i64.store offset=0x12d align=1 (i32.const 0) (local.get 0x12d))
+    (i64.store offset=0x12e align=1 (i32.const 0) (local.get 0x12e))
+    (i64.store offset=0x12f align=1 (i32.const 0) (local.get 0x12f))
+    (i64.store offset=0x130 align=1 (i32.const 0) (local.get 0x130))
+    (i64.store offset=0x131 align=1 (i32.const 0) (local.get 0x131))
+    (i64.store offset=0x132 align=1 (i32.const 0) (local.get 0x132))
+    (i64.store offset=0x133 align=1 (i32.const 0) (local.get 0x133))
+    (i64.store offset=0x134 align=1 (i32.const 0) (local.get 0x134))
+    (i64.store offset=0x135 align=1 (i32.const 0) (local.get 0x135))
+    (i64.store offset=0x136 align=1 (i32.const 0) (local.get 0x136))
+    (i64.store offset=0x137 align=1 (i32.const 0) (local.get 0x137))
+    (i64.store offset=0x138 align=1 (i32.const 0) (local.get 0x138))
+    (i64.store offset=0x139 align=1 (i32.const 0) (local.get 0x139))
+    (i64.store offset=0x13a align=1 (i32.const 0) (local.get 0x13a))
+    (i64.store offset=0x13b align=1 (i32.const 0) (local.get 0x13b))
+    (i64.store offset=0x13c align=1 (i32.const 0) (local.get 0x13c))
+    (i64.store offset=0x13d align=1 (i32.const 0) (local.get 0x13d))
+    (i64.store offset=0x13e align=1 (i32.const 0) (local.get 0x13e))
+    (i64.store offset=0x13f align=1 (i32.const 0) (local.get 0x13f))
+    (i64.store offset=0x140 align=1 (i32.const 0) (local.get 0x140))
+    (i64.store offset=0x141 align=1 (i32.const 0) (local.get 0x141))
+    (i64.store offset=0x142 align=1 (i32.const 0) (local.get 0x142))
+    (i64.store offset=0x143 align=1 (i32.const 0) (local.get 0x143))
+    (i64.store offset=0x144 align=1 (i32.const 0) (local.get 0x144))
+    (i64.store offset=0x145 align=1 (i32.const 0) (local.get 0x145))
+    (i64.store offset=0x146 align=1 (i32.const 0) (local.get 0x146))
+    (i64.store offset=0x147 align=1 (i32.const 0) (local.get 0x147))
+    (i64.store offset=0x148 align=1 (i32.const 0) (local.get 0x148))
+    (i64.store offset=0x149 align=1 (i32.const 0) (local.get 0x149))
+    (i64.store offset=0x14a align=1 (i32.const 0) (local.get 0x14a))
+    (i64.store offset=0x14b align=1 (i32.const 0) (local.get 0x14b))
+    (i64.store offset=0x14c align=1 (i32.const 0) (local.get 0x14c))
+    (i64.store offset=0x14d align=1 (i32.const 0) (local.get 0x14d))
+    (i64.store offset=0x14e align=1 (i32.const 0) (local.get 0x14e))
+    (i64.store offset=0x14f align=1 (i32.const 0) (local.get 0x14f))
+    (i64.store offset=0x150 align=1 (i32.const 0) (local.get 0x150))
+    (i64.store offset=0x151 align=1 (i32.const 0) (local.get 0x151))
+    (i64.store offset=0x152 align=1 (i32.const 0) (local.get 0x152))
+    (i64.store offset=0x153 align=1 (i32.const 0) (local.get 0x153))
+    (i64.store offset=0x154 align=1 (i32.const 0) (local.get 0x154))
+    (i64.store offset=0x155 align=1 (i32.const 0) (local.get 0x155))
+    (i64.store offset=0x156 align=1 (i32.const 0) (local.get 0x156))
+    (i64.store offset=0x157 align=1 (i32.const 0) (local.get 0x157))
+    (i64.store offset=0x158 align=1 (i32.const 0) (local.get 0x158))
+    (i64.store offset=0x159 align=1 (i32.const 0) (local.get 0x159))
+    (i64.store offset=0x15a align=1 (i32.const 0) (local.get 0x15a))
+    (i64.store offset=0x15b align=1 (i32.const 0) (local.get 0x15b))
+    (i64.store offset=0x15c align=1 (i32.const 0) (local.get 0x15c))
+    (i64.store offset=0x15d align=1 (i32.const 0) (local.get 0x15d))
+    (i64.store offset=0x15e align=1 (i32.const 0) (local.get 0x15e))
+    (i64.store offset=0x15f align=1 (i32.const 0) (local.get 0x15f))
+    (i64.store offset=0x160 align=1 (i32.const 0) (local.get 0x160))
+    (i64.store offset=0x161 align=1 (i32.const 0) (local.get 0x161))
+    (i64.store offset=0x162 align=1 (i32.const 0) (local.get 0x162))
+    (i64.store offset=0x163 align=1 (i32.const 0) (local.get 0x163))
+    (i64.store offset=0x164 align=1 (i32.const 0) (local.get 0x164))
+    (i64.store offset=0x165 align=1 (i32.const 0) (local.get 0x165))
+    (i64.store offset=0x166 align=1 (i32.const 0) (local.get 0x166))
+    (i64.store offset=0x167 align=1 (i32.const 0) (local.get 0x167))
+    (i64.store offset=0x168 align=1 (i32.const 0) (local.get 0x168))
+    (i64.store offset=0x169 align=1 (i32.const 0) (local.get 0x169))
+    (i64.store offset=0x16a align=1 (i32.const 0) (local.get 0x16a))
+    (i64.store offset=0x16b align=1 (i32.const 0) (local.get 0x16b))
+    (i64.store offset=0x16c align=1 (i32.const 0) (local.get 0x16c))
+    (i64.store offset=0x16d align=1 (i32.const 0) (local.get 0x16d))
+    (i64.store offset=0x16e align=1 (i32.const 0) (local.get 0x16e))
+    (i64.store offset=0x16f align=1 (i32.const 0) (local.get 0x16f))
+    (i64.store offset=0x170 align=1 (i32.const 0) (local.get 0x170))
+    (i64.store offset=0x171 align=1 (i32.const 0) (local.get 0x171))
+    (i64.store offset=0x172 align=1 (i32.const 0) (local.get 0x172))
+    (i64.store offset=0x173 align=1 (i32.const 0) (local.get 0x173))
+    (i64.store offset=0x174 align=1 (i32.const 0) (local.get 0x174))
+    (i64.store offset=0x175 align=1 (i32.const 0) (local.get 0x175))
+    (i64.store offset=0x176 align=1 (i32.const 0) (local.get 0x176))
+    (i64.store offset=0x177 align=1 (i32.const 0) (local.get 0x177))
+    (i64.store offset=0x178 align=1 (i32.const 0) (local.get 0x178))
+    (i64.store offset=0x179 align=1 (i32.const 0) (local.get 0x179))
+    (i64.store offset=0x17a align=1 (i32.const 0) (local.get 0x17a))
+    (i64.store offset=0x17b align=1 (i32.const 0) (local.get 0x17b))
+    (i64.store offset=0x17c align=1 (i32.const 0) (local.get 0x17c))
+    (i64.store offset=0x17d align=1 (i32.const 0) (local.get 0x17d))
+    (i64.store offset=0x17e align=1 (i32.const 0) (local.get 0x17e))
+    (i64.store offset=0x17f align=1 (i32.const 0) (local.get 0x17f))
+    (i64.store offset=0x180 align=1 (i32.const 0) (local.get 0x180))
+    (i64.store offset=0x181 align=1 (i32.const 0) (local.get 0x181))
+    (i64.store offset=0x182 align=1 (i32.const 0) (local.get 0x182))
+    (i64.store offset=0x183 align=1 (i32.const 0) (local.get 0x183))
+    (i64.store offset=0x184 align=1 (i32.const 0) (local.get 0x184))
+    (i64.store offset=0x185 align=1 (i32.const 0) (local.get 0x185))
+    (i64.store offset=0x186 align=1 (i32.const 0) (local.get 0x186))
+    (i64.store offset=0x187 align=1 (i32.const 0) (local.get 0x187))
+    (i64.store offset=0x188 align=1 (i32.const 0) (local.get 0x188))
+    (i64.store offset=0x189 align=1 (i32.const 0) (local.get 0x189))
+    (i64.store offset=0x18a align=1 (i32.const 0) (local.get 0x18a))
+    (i64.store offset=0x18b align=1 (i32.const 0) (local.get 0x18b))
+    (i64.store offset=0x18c align=1 (i32.const 0) (local.get 0x18c))
+    (i64.store offset=0x18d align=1 (i32.const 0) (local.get 0x18d))
+    (i64.store offset=0x18e align=1 (i32.const 0) (local.get 0x18e))
+    (i64.store offset=0x18f align=1 (i32.const 0) (local.get 0x18f))
+    (i64.store offset=0x190 align=1 (i32.const 0) (local.get 0x190))
+    (i64.store offset=0x191 align=1 (i32.const 0) (local.get 0x191))
+    (i64.store offset=0x192 align=1 (i32.const 0) (local.get 0x192))
+    (i64.store offset=0x193 align=1 (i32.const 0) (local.get 0x193))
+    (i64.store offset=0x194 align=1 (i32.const 0) (local.get 0x194))
+    (i64.store offset=0x195 align=1 (i32.const 0) (local.get 0x195))
+    (i64.store offset=0x196 align=1 (i32.const 0) (local.get 0x196))
+    (i64.store offset=0x197 align=1 (i32.const 0) (local.get 0x197))
+    (i64.store offset=0x198 align=1 (i32.const 0) (local.get 0x198))
+    (i64.store offset=0x199 align=1 (i32.const 0) (local.get 0x199))
+    (i64.store offset=0x19a align=1 (i32.const 0) (local.get 0x19a))
+    (i64.store offset=0x19b align=1 (i32.const 0) (local.get 0x19b))
+    (i64.store offset=0x19c align=1 (i32.const 0) (local.get 0x19c))
+    (i64.store offset=0x19d align=1 (i32.const 0) (local.get 0x19d))
+    (i64.store offset=0x19e align=1 (i32.const 0) (local.get 0x19e))
+    (i64.store offset=0x19f align=1 (i32.const 0) (local.get 0x19f))
+    (i64.store offset=0x1a0 align=1 (i32.const 0) (local.get 0x1a0))
+    (i64.store offset=0x1a1 align=1 (i32.const 0) (local.get 0x1a1))
+    (i64.store offset=0x1a2 align=1 (i32.const 0) (local.get 0x1a2))
+    (i64.store offset=0x1a3 align=1 (i32.const 0) (local.get 0x1a3))
+    (i64.store offset=0x1a4 align=1 (i32.const 0) (local.get 0x1a4))
+    (i64.store offset=0x1a5 align=1 (i32.const 0) (local.get 0x1a5))
+    (i64.store offset=0x1a6 align=1 (i32.const 0) (local.get 0x1a6))
+    (i64.store offset=0x1a7 align=1 (i32.const 0) (local.get 0x1a7))
+    (i64.store offset=0x1a8 align=1 (i32.const 0) (local.get 0x1a8))
+    (i64.store offset=0x1a9 align=1 (i32.const 0) (local.get 0x1a9))
+    (i64.store offset=0x1aa align=1 (i32.const 0) (local.get 0x1aa))
+    (i64.store offset=0x1ab align=1 (i32.const 0) (local.get 0x1ab))
+    (i64.store offset=0x1ac align=1 (i32.const 0) (local.get 0x1ac))
+    (i64.store offset=0x1ad align=1 (i32.const 0) (local.get 0x1ad))
+    (i64.store offset=0x1ae align=1 (i32.const 0) (local.get 0x1ae))
+    (i64.store offset=0x1af align=1 (i32.const 0) (local.get 0x1af))
+    (i64.store offset=0x1b0 align=1 (i32.const 0) (local.get 0x1b0))
+    (i64.store offset=0x1b1 align=1 (i32.const 0) (local.get 0x1b1))
+    (i64.store offset=0x1b2 align=1 (i32.const 0) (local.get 0x1b2))
+    (i64.store offset=0x1b3 align=1 (i32.const 0) (local.get 0x1b3))
+    (i64.store offset=0x1b4 align=1 (i32.const 0) (local.get 0x1b4))
+    (i64.store offset=0x1b5 align=1 (i32.const 0) (local.get 0x1b5))
+    (i64.store offset=0x1b6 align=1 (i32.const 0) (local.get 0x1b6))
+    (i64.store offset=0x1b7 align=1 (i32.const 0) (local.get 0x1b7))
+    (i64.store offset=0x1b8 align=1 (i32.const 0) (local.get 0x1b8))
+    (i64.store offset=0x1b9 align=1 (i32.const 0) (local.get 0x1b9))
+    (i64.store offset=0x1ba align=1 (i32.const 0) (local.get 0x1ba))
+    (i64.store offset=0x1bb align=1 (i32.const 0) (local.get 0x1bb))
+    (i64.store offset=0x1bc align=1 (i32.const 0) (local.get 0x1bc))
+    (i64.store offset=0x1bd align=1 (i32.const 0) (local.get 0x1bd))
+    (i64.store offset=0x1be align=1 (i32.const 0) (local.get 0x1be))
+    (i64.store offset=0x1bf align=1 (i32.const 0) (local.get 0x1bf))
+    (i64.store offset=0x1c0 align=1 (i32.const 0) (local.get 0x1c0))
+    (i64.store offset=0x1c1 align=1 (i32.const 0) (local.get 0x1c1))
+    (i64.store offset=0x1c2 align=1 (i32.const 0) (local.get 0x1c2))
+    (i64.store offset=0x1c3 align=1 (i32.const 0) (local.get 0x1c3))
+    (i64.store offset=0x1c4 align=1 (i32.const 0) (local.get 0x1c4))
+    (i64.store offset=0x1c5 align=1 (i32.const 0) (local.get 0x1c5))
+    (i64.store offset=0x1c6 align=1 (i32.const 0) (local.get 0x1c6))
+    (i64.store offset=0x1c7 align=1 (i32.const 0) (local.get 0x1c7))
+    (i64.store offset=0x1c8 align=1 (i32.const 0) (local.get 0x1c8))
+    (i64.store offset=0x1c9 align=1 (i32.const 0) (local.get 0x1c9))
+    (i64.store offset=0x1ca align=1 (i32.const 0) (local.get 0x1ca))
+    (i64.store offset=0x1cb align=1 (i32.const 0) (local.get 0x1cb))
+    (i64.store offset=0x1cc align=1 (i32.const 0) (local.get 0x1cc))
+    (i64.store offset=0x1cd align=1 (i32.const 0) (local.get 0x1cd))
+    (i64.store offset=0x1ce align=1 (i32.const 0) (local.get 0x1ce))
+    (i64.store offset=0x1cf align=1 (i32.const 0) (local.get 0x1cf))
+    (i64.store offset=0x1d0 align=1 (i32.const 0) (local.get 0x1d0))
+    (i64.store offset=0x1d1 align=1 (i32.const 0) (local.get 0x1d1))
+    (i64.store offset=0x1d2 align=1 (i32.const 0) (local.get 0x1d2))
+    (i64.store offset=0x1d3 align=1 (i32.const 0) (local.get 0x1d3))
+    (i64.store offset=0x1d4 align=1 (i32.const 0) (local.get 0x1d4))
+    (i64.store offset=0x1d5 align=1 (i32.const 0) (local.get 0x1d5))
+    (i64.store offset=0x1d6 align=1 (i32.const 0) (local.get 0x1d6))
+    (i64.store offset=0x1d7 align=1 (i32.const 0) (local.get 0x1d7))
+    (i64.store offset=0x1d8 align=1 (i32.const 0) (local.get 0x1d8))
+    (i64.store offset=0x1d9 align=1 (i32.const 0) (local.get 0x1d9))
+    (i64.store offset=0x1da align=1 (i32.const 0) (local.get 0x1da))
+    (i64.store offset=0x1db align=1 (i32.const 0) (local.get 0x1db))
+    (i64.store offset=0x1dc align=1 (i32.const 0) (local.get 0x1dc))
+    (i64.store offset=0x1dd align=1 (i32.const 0) (local.get 0x1dd))
+    (i64.store offset=0x1de align=1 (i32.const 0) (local.get 0x1de))
+    (i64.store offset=0x1df align=1 (i32.const 0) (local.get 0x1df))
+    (i64.store offset=0x1e0 align=1 (i32.const 0) (local.get 0x1e0))
+    (i64.store offset=0x1e1 align=1 (i32.const 0) (local.get 0x1e1))
+    (i64.store offset=0x1e2 align=1 (i32.const 0) (local.get 0x1e2))
+    (i64.store offset=0x1e3 align=1 (i32.const 0) (local.get 0x1e3))
+    (i64.store offset=0x1e4 align=1 (i32.const 0) (local.get 0x1e4))
+    (i64.store offset=0x1e5 align=1 (i32.const 0) (local.get 0x1e5))
+    (i64.store offset=0x1e6 align=1 (i32.const 0) (local.get 0x1e6))
+    (i64.store offset=0x1e7 align=1 (i32.const 0) (local.get 0x1e7))
+    (i64.store offset=0x1e8 align=1 (i32.const 0) (local.get 0x1e8))
+    (i64.store offset=0x1e9 align=1 (i32.const 0) (local.get 0x1e9))
+    (i64.store offset=0x1ea align=1 (i32.const 0) (local.get 0x1ea))
+    (i64.store offset=0x1eb align=1 (i32.const 0) (local.get 0x1eb))
+    (i64.store offset=0x1ec align=1 (i32.const 0) (local.get 0x1ec))
+    (i64.store offset=0x1ed align=1 (i32.const 0) (local.get 0x1ed))
+    (i64.store offset=0x1ee align=1 (i32.const 0) (local.get 0x1ee))
+    (i64.store offset=0x1ef align=1 (i32.const 0) (local.get 0x1ef))
+    (i64.store offset=0x1f0 align=1 (i32.const 0) (local.get 0x1f0))
+    (i64.store offset=0x1f1 align=1 (i32.const 0) (local.get 0x1f1))
+    (i64.store offset=0x1f2 align=1 (i32.const 0) (local.get 0x1f2))
+    (i64.store offset=0x1f3 align=1 (i32.const 0) (local.get 0x1f3))
+    (i64.store offset=0x1f4 align=1 (i32.const 0) (local.get 0x1f4))
+    (i64.store offset=0x1f5 align=1 (i32.const 0) (local.get 0x1f5))
+    (i64.store offset=0x1f6 align=1 (i32.const 0) (local.get 0x1f6))
+    (i64.store offset=0x1f7 align=1 (i32.const 0) (local.get 0x1f7))
+    (i64.store offset=0x1f8 align=1 (i32.const 0) (local.get 0x1f8))
+    (i64.store offset=0x1f9 align=1 (i32.const 0) (local.get 0x1f9))
+    (i64.store offset=0x1fa align=1 (i32.const 0) (local.get 0x1fa))
+    (i64.store offset=0x1fb align=1 (i32.const 0) (local.get 0x1fb))
+    (i64.store offset=0x1fc align=1 (i32.const 0) (local.get 0x1fc))
+    (i64.store offset=0x1fd align=1 (i32.const 0) (local.get 0x1fd))
+    (i64.store offset=0x1fe align=1 (i32.const 0) (local.get 0x1fe))
+    (i64.store offset=0x1ff align=1 (i32.const 0) (local.get 0x1ff))
+    (i64.store offset=0x200 align=1 (i32.const 0) (local.get 0x200))
+    (i64.store offset=0x201 align=1 (i32.const 0) (local.get 0x201))
+    (i64.store offset=0x202 align=1 (i32.const 0) (local.get 0x202))
+    (i64.store offset=0x203 align=1 (i32.const 0) (local.get 0x203))
+    (i64.store offset=0x204 align=1 (i32.const 0) (local.get 0x204))
+    (i64.store offset=0x205 align=1 (i32.const 0) (local.get 0x205))
+    (i64.store offset=0x206 align=1 (i32.const 0) (local.get 0x206))
+    (i64.store offset=0x207 align=1 (i32.const 0) (local.get 0x207))
+    (i64.store offset=0x208 align=1 (i32.const 0) (local.get 0x208))
+    (i64.store offset=0x209 align=1 (i32.const 0) (local.get 0x209))
+    (i64.store offset=0x20a align=1 (i32.const 0) (local.get 0x20a))
+    (i64.store offset=0x20b align=1 (i32.const 0) (local.get 0x20b))
+    (i64.store offset=0x20c align=1 (i32.const 0) (local.get 0x20c))
+    (i64.store offset=0x20d align=1 (i32.const 0) (local.get 0x20d))
+    (i64.store offset=0x20e align=1 (i32.const 0) (local.get 0x20e))
+    (i64.store offset=0x20f align=1 (i32.const 0) (local.get 0x20f))
+    (i64.store offset=0x210 align=1 (i32.const 0) (local.get 0x210))
+    (i64.store offset=0x211 align=1 (i32.const 0) (local.get 0x211))
+    (i64.store offset=0x212 align=1 (i32.const 0) (local.get 0x212))
+    (i64.store offset=0x213 align=1 (i32.const 0) (local.get 0x213))
+    (i64.store offset=0x214 align=1 (i32.const 0) (local.get 0x214))
+    (i64.store offset=0x215 align=1 (i32.const 0) (local.get 0x215))
+    (i64.store offset=0x216 align=1 (i32.const 0) (local.get 0x216))
+    (i64.store offset=0x217 align=1 (i32.const 0) (local.get 0x217))
+    (i64.store offset=0x218 align=1 (i32.const 0) (local.get 0x218))
+    (i64.store offset=0x219 align=1 (i32.const 0) (local.get 0x219))
+    (i64.store offset=0x21a align=1 (i32.const 0) (local.get 0x21a))
+    (i64.store offset=0x21b align=1 (i32.const 0) (local.get 0x21b))
+    (i64.store offset=0x21c align=1 (i32.const 0) (local.get 0x21c))
+    (i64.store offset=0x21d align=1 (i32.const 0) (local.get 0x21d))
+    (i64.store offset=0x21e align=1 (i32.const 0) (local.get 0x21e))
+    (i64.store offset=0x21f align=1 (i32.const 0) (local.get 0x21f))
+    (i64.store offset=0x220 align=1 (i32.const 0) (local.get 0x220))
+    (i64.store offset=0x221 align=1 (i32.const 0) (local.get 0x221))
+    (i64.store offset=0x222 align=1 (i32.const 0) (local.get 0x222))
+    (i64.store offset=0x223 align=1 (i32.const 0) (local.get 0x223))
+    (i64.store offset=0x224 align=1 (i32.const 0) (local.get 0x224))
+    (i64.store offset=0x225 align=1 (i32.const 0) (local.get 0x225))
+    (i64.store offset=0x226 align=1 (i32.const 0) (local.get 0x226))
+    (i64.store offset=0x227 align=1 (i32.const 0) (local.get 0x227))
+    (i64.store offset=0x228 align=1 (i32.const 0) (local.get 0x228))
+    (i64.store offset=0x229 align=1 (i32.const 0) (local.get 0x229))
+    (i64.store offset=0x22a align=1 (i32.const 0) (local.get 0x22a))
+    (i64.store offset=0x22b align=1 (i32.const 0) (local.get 0x22b))
+    (i64.store offset=0x22c align=1 (i32.const 0) (local.get 0x22c))
+    (i64.store offset=0x22d align=1 (i32.const 0) (local.get 0x22d))
+    (i64.store offset=0x22e align=1 (i32.const 0) (local.get 0x22e))
+    (i64.store offset=0x22f align=1 (i32.const 0) (local.get 0x22f))
+    (i64.store offset=0x230 align=1 (i32.const 0) (local.get 0x230))
+    (i64.store offset=0x231 align=1 (i32.const 0) (local.get 0x231))
+    (i64.store offset=0x232 align=1 (i32.const 0) (local.get 0x232))
+    (i64.store offset=0x233 align=1 (i32.const 0) (local.get 0x233))
+    (i64.store offset=0x234 align=1 (i32.const 0) (local.get 0x234))
+    (i64.store offset=0x235 align=1 (i32.const 0) (local.get 0x235))
+    (i64.store offset=0x236 align=1 (i32.const 0) (local.get 0x236))
+    (i64.store offset=0x237 align=1 (i32.const 0) (local.get 0x237))
+    (i64.store offset=0x238 align=1 (i32.const 0) (local.get 0x238))
+    (i64.store offset=0x239 align=1 (i32.const 0) (local.get 0x239))
+    (i64.store offset=0x23a align=1 (i32.const 0) (local.get 0x23a))
+    (i64.store offset=0x23b align=1 (i32.const 0) (local.get 0x23b))
+    (i64.store offset=0x23c align=1 (i32.const 0) (local.get 0x23c))
+    (i64.store offset=0x23d align=1 (i32.const 0) (local.get 0x23d))
+    (i64.store offset=0x23e align=1 (i32.const 0) (local.get 0x23e))
+    (i64.store offset=0x23f align=1 (i32.const 0) (local.get 0x23f))
+    (i64.store offset=0x240 align=1 (i32.const 0) (local.get 0x240))
+    (i64.store offset=0x241 align=1 (i32.const 0) (local.get 0x241))
+    (i64.store offset=0x242 align=1 (i32.const 0) (local.get 0x242))
+    (i64.store offset=0x243 align=1 (i32.const 0) (local.get 0x243))
+    (i64.store offset=0x244 align=1 (i32.const 0) (local.get 0x244))
+    (i64.store offset=0x245 align=1 (i32.const 0) (local.get 0x245))
+    (i64.store offset=0x246 align=1 (i32.const 0) (local.get 0x246))
+    (i64.store offset=0x247 align=1 (i32.const 0) (local.get 0x247))
+    (i64.store offset=0x248 align=1 (i32.const 0) (local.get 0x248))
+    (i64.store offset=0x249 align=1 (i32.const 0) (local.get 0x249))
+    (i64.store offset=0x24a align=1 (i32.const 0) (local.get 0x24a))
+    (i64.store offset=0x24b align=1 (i32.const 0) (local.get 0x24b))
+    (i64.store offset=0x24c align=1 (i32.const 0) (local.get 0x24c))
+    (i64.store offset=0x24d align=1 (i32.const 0) (local.get 0x24d))
+    (i64.store offset=0x24e align=1 (i32.const 0) (local.get 0x24e))
+    (i64.store offset=0x24f align=1 (i32.const 0) (local.get 0x24f))
+    (i64.store offset=0x250 align=1 (i32.const 0) (local.get 0x250))
+    (i64.store offset=0x251 align=1 (i32.const 0) (local.get 0x251))
+    (i64.store offset=0x252 align=1 (i32.const 0) (local.get 0x252))
+    (i64.store offset=0x253 align=1 (i32.const 0) (local.get 0x253))
+    (i64.store offset=0x254 align=1 (i32.const 0) (local.get 0x254))
+    (i64.store offset=0x255 align=1 (i32.const 0) (local.get 0x255))
+    (i64.store offset=0x256 align=1 (i32.const 0) (local.get 0x256))
+    (i64.store offset=0x257 align=1 (i32.const 0) (local.get 0x257))
+    (i64.store offset=0x258 align=1 (i32.const 0) (local.get 0x258))
+    (i64.store offset=0x259 align=1 (i32.const 0) (local.get 0x259))
+    (i64.store offset=0x25a align=1 (i32.const 0) (local.get 0x25a))
+    (i64.store offset=0x25b align=1 (i32.const 0) (local.get 0x25b))
+    (i64.store offset=0x25c align=1 (i32.const 0) (local.get 0x25c))
+    (i64.store offset=0x25d align=1 (i32.const 0) (local.get 0x25d))
+    (i64.store offset=0x25e align=1 (i32.const 0) (local.get 0x25e))
+    (i64.store offset=0x25f align=1 (i32.const 0) (local.get 0x25f))
+    (i64.store offset=0x260 align=1 (i32.const 0) (local.get 0x260))
+    (i64.store offset=0x261 align=1 (i32.const 0) (local.get 0x261))
+    (i64.store offset=0x262 align=1 (i32.const 0) (local.get 0x262))
+    (i64.store offset=0x263 align=1 (i32.const 0) (local.get 0x263))
+    (i64.store offset=0x264 align=1 (i32.const 0) (local.get 0x264))
+    (i64.store offset=0x265 align=1 (i32.const 0) (local.get 0x265))
+    (i64.store offset=0x266 align=1 (i32.const 0) (local.get 0x266))
+    (i64.store offset=0x267 align=1 (i32.const 0) (local.get 0x267))
+    (i64.store offset=0x268 align=1 (i32.const 0) (local.get 0x268))
+    (i64.store offset=0x269 align=1 (i32.const 0) (local.get 0x269))
+    (i64.store offset=0x26a align=1 (i32.const 0) (local.get 0x26a))
+    (i64.store offset=0x26b align=1 (i32.const 0) (local.get 0x26b))
+    (i64.store offset=0x26c align=1 (i32.const 0) (local.get 0x26c))
+    (i64.store offset=0x26d align=1 (i32.const 0) (local.get 0x26d))
+    (i64.store offset=0x26e align=1 (i32.const 0) (local.get 0x26e))
+    (i64.store offset=0x26f align=1 (i32.const 0) (local.get 0x26f))
+    (i64.store offset=0x270 align=1 (i32.const 0) (local.get 0x270))
+    (i64.store offset=0x271 align=1 (i32.const 0) (local.get 0x271))
+    (i64.store offset=0x272 align=1 (i32.const 0) (local.get 0x272))
+    (i64.store offset=0x273 align=1 (i32.const 0) (local.get 0x273))
+    (i64.store offset=0x274 align=1 (i32.const 0) (local.get 0x274))
+    (i64.store offset=0x275 align=1 (i32.const 0) (local.get 0x275))
+    (i64.store offset=0x276 align=1 (i32.const 0) (local.get 0x276))
+    (i64.store offset=0x277 align=1 (i32.const 0) (local.get 0x277))
+    (i64.store offset=0x278 align=1 (i32.const 0) (local.get 0x278))
+    (i64.store offset=0x279 align=1 (i32.const 0) (local.get 0x279))
+    (i64.store offset=0x27a align=1 (i32.const 0) (local.get 0x27a))
+    (i64.store offset=0x27b align=1 (i32.const 0) (local.get 0x27b))
+    (i64.store offset=0x27c align=1 (i32.const 0) (local.get 0x27c))
+    (i64.store offset=0x27d align=1 (i32.const 0) (local.get 0x27d))
+    (i64.store offset=0x27e align=1 (i32.const 0) (local.get 0x27e))
+    (i64.store offset=0x27f align=1 (i32.const 0) (local.get 0x27f))
+    (i64.store offset=0x280 align=1 (i32.const 0) (local.get 0x280))
+    (i64.store offset=0x281 align=1 (i32.const 0) (local.get 0x281))
+    (i64.store offset=0x282 align=1 (i32.const 0) (local.get 0x282))
+    (i64.store offset=0x283 align=1 (i32.const 0) (local.get 0x283))
+    (i64.store offset=0x284 align=1 (i32.const 0) (local.get 0x284))
+    (i64.store offset=0x285 align=1 (i32.const 0) (local.get 0x285))
+    (i64.store offset=0x286 align=1 (i32.const 0) (local.get 0x286))
+    (i64.store offset=0x287 align=1 (i32.const 0) (local.get 0x287))
+    (i64.store offset=0x288 align=1 (i32.const 0) (local.get 0x288))
+    (i64.store offset=0x289 align=1 (i32.const 0) (local.get 0x289))
+    (i64.store offset=0x28a align=1 (i32.const 0) (local.get 0x28a))
+    (i64.store offset=0x28b align=1 (i32.const 0) (local.get 0x28b))
+    (i64.store offset=0x28c align=1 (i32.const 0) (local.get 0x28c))
+    (i64.store offset=0x28d align=1 (i32.const 0) (local.get 0x28d))
+    (i64.store offset=0x28e align=1 (i32.const 0) (local.get 0x28e))
+    (i64.store offset=0x28f align=1 (i32.const 0) (local.get 0x28f))
+    (i64.store offset=0x290 align=1 (i32.const 0) (local.get 0x290))
+    (i64.store offset=0x291 align=1 (i32.const 0) (local.get 0x291))
+    (i64.store offset=0x292 align=1 (i32.const 0) (local.get 0x292))
+    (i64.store offset=0x293 align=1 (i32.const 0) (local.get 0x293))
+    (i64.store offset=0x294 align=1 (i32.const 0) (local.get 0x294))
+    (i64.store offset=0x295 align=1 (i32.const 0) (local.get 0x295))
+    (i64.store offset=0x296 align=1 (i32.const 0) (local.get 0x296))
+    (i64.store offset=0x297 align=1 (i32.const 0) (local.get 0x297))
+    (i64.store offset=0x298 align=1 (i32.const 0) (local.get 0x298))
+    (i64.store offset=0x299 align=1 (i32.const 0) (local.get 0x299))
+    (i64.store offset=0x29a align=1 (i32.const 0) (local.get 0x29a))
+    (i64.store offset=0x29b align=1 (i32.const 0) (local.get 0x29b))
+    (i64.store offset=0x29c align=1 (i32.const 0) (local.get 0x29c))
+    (i64.store offset=0x29d align=1 (i32.const 0) (local.get 0x29d))
+    (i64.store offset=0x29e align=1 (i32.const 0) (local.get 0x29e))
+    (i64.store offset=0x29f align=1 (i32.const 0) (local.get 0x29f))
+    (i64.store offset=0x2a0 align=1 (i32.const 0) (local.get 0x2a0))
+    (i64.store offset=0x2a1 align=1 (i32.const 0) (local.get 0x2a1))
+    (i64.store offset=0x2a2 align=1 (i32.const 0) (local.get 0x2a2))
+    (i64.store offset=0x2a3 align=1 (i32.const 0) (local.get 0x2a3))
+    (i64.store offset=0x2a4 align=1 (i32.const 0) (local.get 0x2a4))
+    (i64.store offset=0x2a5 align=1 (i32.const 0) (local.get 0x2a5))
+    (i64.store offset=0x2a6 align=1 (i32.const 0) (local.get 0x2a6))
+    (i64.store offset=0x2a7 align=1 (i32.const 0) (local.get 0x2a7))
+    (i64.store offset=0x2a8 align=1 (i32.const 0) (local.get 0x2a8))
+    (i64.store offset=0x2a9 align=1 (i32.const 0) (local.get 0x2a9))
+    (i64.store offset=0x2aa align=1 (i32.const 0) (local.get 0x2aa))
+    (i64.store offset=0x2ab align=1 (i32.const 0) (local.get 0x2ab))
+    (i64.store offset=0x2ac align=1 (i32.const 0) (local.get 0x2ac))
+    (i64.store offset=0x2ad align=1 (i32.const 0) (local.get 0x2ad))
+    (i64.store offset=0x2ae align=1 (i32.const 0) (local.get 0x2ae))
+    (i64.store offset=0x2af align=1 (i32.const 0) (local.get 0x2af))
+    (i64.store offset=0x2b0 align=1 (i32.const 0) (local.get 0x2b0))
+    (i64.store offset=0x2b1 align=1 (i32.const 0) (local.get 0x2b1))
+    (i64.store offset=0x2b2 align=1 (i32.const 0) (local.get 0x2b2))
+    (i64.store offset=0x2b3 align=1 (i32.const 0) (local.get 0x2b3))
+    (i64.store offset=0x2b4 align=1 (i32.const 0) (local.get 0x2b4))
+    (i64.store offset=0x2b5 align=1 (i32.const 0) (local.get 0x2b5))
+    (i64.store offset=0x2b6 align=1 (i32.const 0) (local.get 0x2b6))
+    (i64.store offset=0x2b7 align=1 (i32.const 0) (local.get 0x2b7))
+    (i64.store offset=0x2b8 align=1 (i32.const 0) (local.get 0x2b8))
+    (i64.store offset=0x2b9 align=1 (i32.const 0) (local.get 0x2b9))
+    (i64.store offset=0x2ba align=1 (i32.const 0) (local.get 0x2ba))
+    (i64.store offset=0x2bb align=1 (i32.const 0) (local.get 0x2bb))
+    (i64.store offset=0x2bc align=1 (i32.const 0) (local.get 0x2bc))
+    (i64.store offset=0x2bd align=1 (i32.const 0) (local.get 0x2bd))
+    (i64.store offset=0x2be align=1 (i32.const 0) (local.get 0x2be))
+    (i64.store offset=0x2bf align=1 (i32.const 0) (local.get 0x2bf))
+    (i64.store offset=0x2c0 align=1 (i32.const 0) (local.get 0x2c0))
+    (i64.store offset=0x2c1 align=1 (i32.const 0) (local.get 0x2c1))
+    (i64.store offset=0x2c2 align=1 (i32.const 0) (local.get 0x2c2))
+    (i64.store offset=0x2c3 align=1 (i32.const 0) (local.get 0x2c3))
+    (i64.store offset=0x2c4 align=1 (i32.const 0) (local.get 0x2c4))
+    (i64.store offset=0x2c5 align=1 (i32.const 0) (local.get 0x2c5))
+    (i64.store offset=0x2c6 align=1 (i32.const 0) (local.get 0x2c6))
+    (i64.store offset=0x2c7 align=1 (i32.const 0) (local.get 0x2c7))
+    (i64.store offset=0x2c8 align=1 (i32.const 0) (local.get 0x2c8))
+    (i64.store offset=0x2c9 align=1 (i32.const 0) (local.get 0x2c9))
+    (i64.store offset=0x2ca align=1 (i32.const 0) (local.get 0x2ca))
+    (i64.store offset=0x2cb align=1 (i32.const 0) (local.get 0x2cb))
+    (i64.store offset=0x2cc align=1 (i32.const 0) (local.get 0x2cc))
+    (i64.store offset=0x2cd align=1 (i32.const 0) (local.get 0x2cd))
+    (i64.store offset=0x2ce align=1 (i32.const 0) (local.get 0x2ce))
+    (i64.store offset=0x2cf align=1 (i32.const 0) (local.get 0x2cf))
+    (i64.store offset=0x2d0 align=1 (i32.const 0) (local.get 0x2d0))
+    (i64.store offset=0x2d1 align=1 (i32.const 0) (local.get 0x2d1))
+    (i64.store offset=0x2d2 align=1 (i32.const 0) (local.get 0x2d2))
+    (i64.store offset=0x2d3 align=1 (i32.const 0) (local.get 0x2d3))
+    (i64.store offset=0x2d4 align=1 (i32.const 0) (local.get 0x2d4))
+    (i64.store offset=0x2d5 align=1 (i32.const 0) (local.get 0x2d5))
+    (i64.store offset=0x2d6 align=1 (i32.const 0) (local.get 0x2d6))
+    (i64.store offset=0x2d7 align=1 (i32.const 0) (local.get 0x2d7))
+    (i64.store offset=0x2d8 align=1 (i32.const 0) (local.get 0x2d8))
+    (i64.store offset=0x2d9 align=1 (i32.const 0) (local.get 0x2d9))
+    (i64.store offset=0x2da align=1 (i32.const 0) (local.get 0x2da))
+    (i64.store offset=0x2db align=1 (i32.const 0) (local.get 0x2db))
+    (i64.store offset=0x2dc align=1 (i32.const 0) (local.get 0x2dc))
+    (i64.store offset=0x2dd align=1 (i32.const 0) (local.get 0x2dd))
+    (i64.store offset=0x2de align=1 (i32.const 0) (local.get 0x2de))
+    (i64.store offset=0x2df align=1 (i32.const 0) (local.get 0x2df))
+    (i64.store offset=0x2e0 align=1 (i32.const 0) (local.get 0x2e0))
+    (i64.store offset=0x2e1 align=1 (i32.const 0) (local.get 0x2e1))
+    (i64.store offset=0x2e2 align=1 (i32.const 0) (local.get 0x2e2))
+    (i64.store offset=0x2e3 align=1 (i32.const 0) (local.get 0x2e3))
+    (i64.store offset=0x2e4 align=1 (i32.const 0) (local.get 0x2e4))
+    (i64.store offset=0x2e5 align=1 (i32.const 0) (local.get 0x2e5))
+    (i64.store offset=0x2e6 align=1 (i32.const 0) (local.get 0x2e6))
+    (i64.store offset=0x2e7 align=1 (i32.const 0) (local.get 0x2e7))
+    (i64.store offset=0x2e8 align=1 (i32.const 0) (local.get 0x2e8))
+    (i64.store offset=0x2e9 align=1 (i32.const 0) (local.get 0x2e9))
+    (i64.store offset=0x2ea align=1 (i32.const 0) (local.get 0x2ea))
+    (i64.store offset=0x2eb align=1 (i32.const 0) (local.get 0x2eb))
+    (i64.store offset=0x2ec align=1 (i32.const 0) (local.get 0x2ec))
+    (i64.store offset=0x2ed align=1 (i32.const 0) (local.get 0x2ed))
+    (i64.store offset=0x2ee align=1 (i32.const 0) (local.get 0x2ee))
+    (i64.store offset=0x2ef align=1 (i32.const 0) (local.get 0x2ef))
+    (i64.store offset=0x2f0 align=1 (i32.const 0) (local.get 0x2f0))
+    (i64.store offset=0x2f1 align=1 (i32.const 0) (local.get 0x2f1))
+    (i64.store offset=0x2f2 align=1 (i32.const 0) (local.get 0x2f2))
+    (i64.store offset=0x2f3 align=1 (i32.const 0) (local.get 0x2f3))
+    (i64.store offset=0x2f4 align=1 (i32.const 0) (local.get 0x2f4))
+    (i64.store offset=0x2f5 align=1 (i32.const 0) (local.get 0x2f5))
+    (i64.store offset=0x2f6 align=1 (i32.const 0) (local.get 0x2f6))
+    (i64.store offset=0x2f7 align=1 (i32.const 0) (local.get 0x2f7))
+    (i64.store offset=0x2f8 align=1 (i32.const 0) (local.get 0x2f8))
+    (i64.store offset=0x2f9 align=1 (i32.const 0) (local.get 0x2f9))
+    (i64.store offset=0x2fa align=1 (i32.const 0) (local.get 0x2fa))
+    (i64.store offset=0x2fb align=1 (i32.const 0) (local.get 0x2fb))
+    (i64.store offset=0x2fc align=1 (i32.const 0) (local.get 0x2fc))
+    (i64.store offset=0x2fd align=1 (i32.const 0) (local.get 0x2fd))
+    (i64.store offset=0x2fe align=1 (i32.const 0) (local.get 0x2fe))
+    (i64.store offset=0x2ff align=1 (i32.const 0) (local.get 0x2ff))
+    (i64.store offset=0x300 align=1 (i32.const 0) (local.get 0x300))
+    (i64.store offset=0x301 align=1 (i32.const 0) (local.get 0x301))
+    (i64.store offset=0x302 align=1 (i32.const 0) (local.get 0x302))
+    (i64.store offset=0x303 align=1 (i32.const 0) (local.get 0x303))
+    (i64.store offset=0x304 align=1 (i32.const 0) (local.get 0x304))
+    (i64.store offset=0x305 align=1 (i32.const 0) (local.get 0x305))
+    (i64.store offset=0x306 align=1 (i32.const 0) (local.get 0x306))
+    (i64.store offset=0x307 align=1 (i32.const 0) (local.get 0x307))
+    (i64.store offset=0x308 align=1 (i32.const 0) (local.get 0x308))
+    (i64.store offset=0x309 align=1 (i32.const 0) (local.get 0x309))
+    (i64.store offset=0x30a align=1 (i32.const 0) (local.get 0x30a))
+    (i64.store offset=0x30b align=1 (i32.const 0) (local.get 0x30b))
+    (i64.store offset=0x30c align=1 (i32.const 0) (local.get 0x30c))
+    (i64.store offset=0x30d align=1 (i32.const 0) (local.get 0x30d))
+    (i64.store offset=0x30e align=1 (i32.const 0) (local.get 0x30e))
+    (i64.store offset=0x30f align=1 (i32.const 0) (local.get 0x30f))
+    (i64.store offset=0x310 align=1 (i32.const 0) (local.get 0x310))
+    (i64.store offset=0x311 align=1 (i32.const 0) (local.get 0x311))
+    (i64.store offset=0x312 align=1 (i32.const 0) (local.get 0x312))
+    (i64.store offset=0x313 align=1 (i32.const 0) (local.get 0x313))
+    (i64.store offset=0x314 align=1 (i32.const 0) (local.get 0x314))
+    (i64.store offset=0x315 align=1 (i32.const 0) (local.get 0x315))
+    (i64.store offset=0x316 align=1 (i32.const 0) (local.get 0x316))
+    (i64.store offset=0x317 align=1 (i32.const 0) (local.get 0x317))
+    (i64.store offset=0x318 align=1 (i32.const 0) (local.get 0x318))
+    (i64.store offset=0x319 align=1 (i32.const 0) (local.get 0x319))
+    (i64.store offset=0x31a align=1 (i32.const 0) (local.get 0x31a))
+    (i64.store offset=0x31b align=1 (i32.const 0) (local.get 0x31b))
+    (i64.store offset=0x31c align=1 (i32.const 0) (local.get 0x31c))
+    (i64.store offset=0x31d align=1 (i32.const 0) (local.get 0x31d))
+    (i64.store offset=0x31e align=1 (i32.const 0) (local.get 0x31e))
+    (i64.store offset=0x31f align=1 (i32.const 0) (local.get 0x31f))
+    (i64.store offset=0x320 align=1 (i32.const 0) (local.get 0x320))
+    (i64.store offset=0x321 align=1 (i32.const 0) (local.get 0x321))
+    (i64.store offset=0x322 align=1 (i32.const 0) (local.get 0x322))
+    (i64.store offset=0x323 align=1 (i32.const 0) (local.get 0x323))
+    (i64.store offset=0x324 align=1 (i32.const 0) (local.get 0x324))
+    (i64.store offset=0x325 align=1 (i32.const 0) (local.get 0x325))
+    (i64.store offset=0x326 align=1 (i32.const 0) (local.get 0x326))
+    (i64.store offset=0x327 align=1 (i32.const 0) (local.get 0x327))
+    (i64.store offset=0x328 align=1 (i32.const 0) (local.get 0x328))
+    (i64.store offset=0x329 align=1 (i32.const 0) (local.get 0x329))
+    (i64.store offset=0x32a align=1 (i32.const 0) (local.get 0x32a))
+    (i64.store offset=0x32b align=1 (i32.const 0) (local.get 0x32b))
+    (i64.store offset=0x32c align=1 (i32.const 0) (local.get 0x32c))
+    (i64.store offset=0x32d align=1 (i32.const 0) (local.get 0x32d))
+    (i64.store offset=0x32e align=1 (i32.const 0) (local.get 0x32e))
+    (i64.store offset=0x32f align=1 (i32.const 0) (local.get 0x32f))
+    (i64.store offset=0x330 align=1 (i32.const 0) (local.get 0x330))
+    (i64.store offset=0x331 align=1 (i32.const 0) (local.get 0x331))
+    (i64.store offset=0x332 align=1 (i32.const 0) (local.get 0x332))
+    (i64.store offset=0x333 align=1 (i32.const 0) (local.get 0x333))
+    (i64.store offset=0x334 align=1 (i32.const 0) (local.get 0x334))
+    (i64.store offset=0x335 align=1 (i32.const 0) (local.get 0x335))
+    (i64.store offset=0x336 align=1 (i32.const 0) (local.get 0x336))
+    (i64.store offset=0x337 align=1 (i32.const 0) (local.get 0x337))
+    (i64.store offset=0x338 align=1 (i32.const 0) (local.get 0x338))
+    (i64.store offset=0x339 align=1 (i32.const 0) (local.get 0x339))
+    (i64.store offset=0x33a align=1 (i32.const 0) (local.get 0x33a))
+    (i64.store offset=0x33b align=1 (i32.const 0) (local.get 0x33b))
+    (i64.store offset=0x33c align=1 (i32.const 0) (local.get 0x33c))
+    (i64.store offset=0x33d align=1 (i32.const 0) (local.get 0x33d))
+    (i64.store offset=0x33e align=1 (i32.const 0) (local.get 0x33e))
+    (i64.store offset=0x33f align=1 (i32.const 0) (local.get 0x33f))
+    (i64.store offset=0x340 align=1 (i32.const 0) (local.get 0x340))
+    (i64.store offset=0x341 align=1 (i32.const 0) (local.get 0x341))
+    (i64.store offset=0x342 align=1 (i32.const 0) (local.get 0x342))
+    (i64.store offset=0x343 align=1 (i32.const 0) (local.get 0x343))
+    (i64.store offset=0x344 align=1 (i32.const 0) (local.get 0x344))
+    (i64.store offset=0x345 align=1 (i32.const 0) (local.get 0x345))
+    (i64.store offset=0x346 align=1 (i32.const 0) (local.get 0x346))
+    (i64.store offset=0x347 align=1 (i32.const 0) (local.get 0x347))
+    (i64.store offset=0x348 align=1 (i32.const 0) (local.get 0x348))
+    (i64.store offset=0x349 align=1 (i32.const 0) (local.get 0x349))
+    (i64.store offset=0x34a align=1 (i32.const 0) (local.get 0x34a))
+    (i64.store offset=0x34b align=1 (i32.const 0) (local.get 0x34b))
+    (i64.store offset=0x34c align=1 (i32.const 0) (local.get 0x34c))
+    (i64.store offset=0x34d align=1 (i32.const 0) (local.get 0x34d))
+    (i64.store offset=0x34e align=1 (i32.const 0) (local.get 0x34e))
+    (i64.store offset=0x34f align=1 (i32.const 0) (local.get 0x34f))
+    (i64.store offset=0x350 align=1 (i32.const 0) (local.get 0x350))
+    (i64.store offset=0x351 align=1 (i32.const 0) (local.get 0x351))
+    (i64.store offset=0x352 align=1 (i32.const 0) (local.get 0x352))
+    (i64.store offset=0x353 align=1 (i32.const 0) (local.get 0x353))
+    (i64.store offset=0x354 align=1 (i32.const 0) (local.get 0x354))
+    (i64.store offset=0x355 align=1 (i32.const 0) (local.get 0x355))
+    (i64.store offset=0x356 align=1 (i32.const 0) (local.get 0x356))
+    (i64.store offset=0x357 align=1 (i32.const 0) (local.get 0x357))
+    (i64.store offset=0x358 align=1 (i32.const 0) (local.get 0x358))
+    (i64.store offset=0x359 align=1 (i32.const 0) (local.get 0x359))
+    (i64.store offset=0x35a align=1 (i32.const 0) (local.get 0x35a))
+    (i64.store offset=0x35b align=1 (i32.const 0) (local.get 0x35b))
+    (i64.store offset=0x35c align=1 (i32.const 0) (local.get 0x35c))
+    (i64.store offset=0x35d align=1 (i32.const 0) (local.get 0x35d))
+    (i64.store offset=0x35e align=1 (i32.const 0) (local.get 0x35e))
+    (i64.store offset=0x35f align=1 (i32.const 0) (local.get 0x35f))
+    (i64.store offset=0x360 align=1 (i32.const 0) (local.get 0x360))
+    (i64.store offset=0x361 align=1 (i32.const 0) (local.get 0x361))
+    (i64.store offset=0x362 align=1 (i32.const 0) (local.get 0x362))
+    (i64.store offset=0x363 align=1 (i32.const 0) (local.get 0x363))
+    (i64.store offset=0x364 align=1 (i32.const 0) (local.get 0x364))
+    (i64.store offset=0x365 align=1 (i32.const 0) (local.get 0x365))
+    (i64.store offset=0x366 align=1 (i32.const 0) (local.get 0x366))
+    (i64.store offset=0x367 align=1 (i32.const 0) (local.get 0x367))
+    (i64.store offset=0x368 align=1 (i32.const 0) (local.get 0x368))
+    (i64.store offset=0x369 align=1 (i32.const 0) (local.get 0x369))
+    (i64.store offset=0x36a align=1 (i32.const 0) (local.get 0x36a))
+    (i64.store offset=0x36b align=1 (i32.const 0) (local.get 0x36b))
+    (i64.store offset=0x36c align=1 (i32.const 0) (local.get 0x36c))
+    (i64.store offset=0x36d align=1 (i32.const 0) (local.get 0x36d))
+    (i64.store offset=0x36e align=1 (i32.const 0) (local.get 0x36e))
+    (i64.store offset=0x36f align=1 (i32.const 0) (local.get 0x36f))
+    (i64.store offset=0x370 align=1 (i32.const 0) (local.get 0x370))
+    (i64.store offset=0x371 align=1 (i32.const 0) (local.get 0x371))
+    (i64.store offset=0x372 align=1 (i32.const 0) (local.get 0x372))
+    (i64.store offset=0x373 align=1 (i32.const 0) (local.get 0x373))
+    (i64.store offset=0x374 align=1 (i32.const 0) (local.get 0x374))
+    (i64.store offset=0x375 align=1 (i32.const 0) (local.get 0x375))
+    (i64.store offset=0x376 align=1 (i32.const 0) (local.get 0x376))
+    (i64.store offset=0x377 align=1 (i32.const 0) (local.get 0x377))
+    (i64.store offset=0x378 align=1 (i32.const 0) (local.get 0x378))
+    (i64.store offset=0x379 align=1 (i32.const 0) (local.get 0x379))
+    (i64.store offset=0x37a align=1 (i32.const 0) (local.get 0x37a))
+    (i64.store offset=0x37b align=1 (i32.const 0) (local.get 0x37b))
+    (i64.store offset=0x37c align=1 (i32.const 0) (local.get 0x37c))
+    (i64.store offset=0x37d align=1 (i32.const 0) (local.get 0x37d))
+    (i64.store offset=0x37e align=1 (i32.const 0) (local.get 0x37e))
+    (i64.store offset=0x37f align=1 (i32.const 0) (local.get 0x37f))
+    (i64.store offset=0x380 align=1 (i32.const 0) (local.get 0x380))
+    (i64.store offset=0x381 align=1 (i32.const 0) (local.get 0x381))
+    (i64.store offset=0x382 align=1 (i32.const 0) (local.get 0x382))
+    (i64.store offset=0x383 align=1 (i32.const 0) (local.get 0x383))
+    (i64.store offset=0x384 align=1 (i32.const 0) (local.get 0x384))
+    (i64.store offset=0x385 align=1 (i32.const 0) (local.get 0x385))
+    (i64.store offset=0x386 align=1 (i32.const 0) (local.get 0x386))
+    (i64.store offset=0x387 align=1 (i32.const 0) (local.get 0x387))
+    (i64.store offset=0x388 align=1 (i32.const 0) (local.get 0x388))
+    (i64.store offset=0x389 align=1 (i32.const 0) (local.get 0x389))
+    (i64.store offset=0x38a align=1 (i32.const 0) (local.get 0x38a))
+    (i64.store offset=0x38b align=1 (i32.const 0) (local.get 0x38b))
+    (i64.store offset=0x38c align=1 (i32.const 0) (local.get 0x38c))
+    (i64.store offset=0x38d align=1 (i32.const 0) (local.get 0x38d))
+    (i64.store offset=0x38e align=1 (i32.const 0) (local.get 0x38e))
+    (i64.store offset=0x38f align=1 (i32.const 0) (local.get 0x38f))
+    (i64.store offset=0x390 align=1 (i32.const 0) (local.get 0x390))
+    (i64.store offset=0x391 align=1 (i32.const 0) (local.get 0x391))
+    (i64.store offset=0x392 align=1 (i32.const 0) (local.get 0x392))
+    (i64.store offset=0x393 align=1 (i32.const 0) (local.get 0x393))
+    (i64.store offset=0x394 align=1 (i32.const 0) (local.get 0x394))
+    (i64.store offset=0x395 align=1 (i32.const 0) (local.get 0x395))
+    (i64.store offset=0x396 align=1 (i32.const 0) (local.get 0x396))
+    (i64.store offset=0x397 align=1 (i32.const 0) (local.get 0x397))
+    (i64.store offset=0x398 align=1 (i32.const 0) (local.get 0x398))
+    (i64.store offset=0x399 align=1 (i32.const 0) (local.get 0x399))
+    (i64.store offset=0x39a align=1 (i32.const 0) (local.get 0x39a))
+    (i64.store offset=0x39b align=1 (i32.const 0) (local.get 0x39b))
+    (i64.store offset=0x39c align=1 (i32.const 0) (local.get 0x39c))
+    (i64.store offset=0x39d align=1 (i32.const 0) (local.get 0x39d))
+    (i64.store offset=0x39e align=1 (i32.const 0) (local.get 0x39e))
+    (i64.store offset=0x39f align=1 (i32.const 0) (local.get 0x39f))
+    (i64.store offset=0x3a0 align=1 (i32.const 0) (local.get 0x3a0))
+    (i64.store offset=0x3a1 align=1 (i32.const 0) (local.get 0x3a1))
+    (i64.store offset=0x3a2 align=1 (i32.const 0) (local.get 0x3a2))
+    (i64.store offset=0x3a3 align=1 (i32.const 0) (local.get 0x3a3))
+    (i64.store offset=0x3a4 align=1 (i32.const 0) (local.get 0x3a4))
+    (i64.store offset=0x3a5 align=1 (i32.const 0) (local.get 0x3a5))
+    (i64.store offset=0x3a6 align=1 (i32.const 0) (local.get 0x3a6))
+    (i64.store offset=0x3a7 align=1 (i32.const 0) (local.get 0x3a7))
+    (i64.store offset=0x3a8 align=1 (i32.const 0) (local.get 0x3a8))
+    (i64.store offset=0x3a9 align=1 (i32.const 0) (local.get 0x3a9))
+    (i64.store offset=0x3aa align=1 (i32.const 0) (local.get 0x3aa))
+    (i64.store offset=0x3ab align=1 (i32.const 0) (local.get 0x3ab))
+    (i64.store offset=0x3ac align=1 (i32.const 0) (local.get 0x3ac))
+    (i64.store offset=0x3ad align=1 (i32.const 0) (local.get 0x3ad))
+    (i64.store offset=0x3ae align=1 (i32.const 0) (local.get 0x3ae))
+    (i64.store offset=0x3af align=1 (i32.const 0) (local.get 0x3af))
+    (i64.store offset=0x3b0 align=1 (i32.const 0) (local.get 0x3b0))
+    (i64.store offset=0x3b1 align=1 (i32.const 0) (local.get 0x3b1))
+    (i64.store offset=0x3b2 align=1 (i32.const 0) (local.get 0x3b2))
+    (i64.store offset=0x3b3 align=1 (i32.const 0) (local.get 0x3b3))
+    (i64.store offset=0x3b4 align=1 (i32.const 0) (local.get 0x3b4))
+    (i64.store offset=0x3b5 align=1 (i32.const 0) (local.get 0x3b5))
+    (i64.store offset=0x3b6 align=1 (i32.const 0) (local.get 0x3b6))
+    (i64.store offset=0x3b7 align=1 (i32.const 0) (local.get 0x3b7))
+    (i64.store offset=0x3b8 align=1 (i32.const 0) (local.get 0x3b8))
+    (i64.store offset=0x3b9 align=1 (i32.const 0) (local.get 0x3b9))
+    (i64.store offset=0x3ba align=1 (i32.const 0) (local.get 0x3ba))
+    (i64.store offset=0x3bb align=1 (i32.const 0) (local.get 0x3bb))
+    (i64.store offset=0x3bc align=1 (i32.const 0) (local.get 0x3bc))
+    (i64.store offset=0x3bd align=1 (i32.const 0) (local.get 0x3bd))
+    (i64.store offset=0x3be align=1 (i32.const 0) (local.get 0x3be))
+    (i64.store offset=0x3bf align=1 (i32.const 0) (local.get 0x3bf))
+    (i64.store offset=0x3c0 align=1 (i32.const 0) (local.get 0x3c0))
+    (i64.store offset=0x3c1 align=1 (i32.const 0) (local.get 0x3c1))
+    (i64.store offset=0x3c2 align=1 (i32.const 0) (local.get 0x3c2))
+    (i64.store offset=0x3c3 align=1 (i32.const 0) (local.get 0x3c3))
+    (i64.store offset=0x3c4 align=1 (i32.const 0) (local.get 0x3c4))
+    (i64.store offset=0x3c5 align=1 (i32.const 0) (local.get 0x3c5))
+    (i64.store offset=0x3c6 align=1 (i32.const 0) (local.get 0x3c6))
+    (i64.store offset=0x3c7 align=1 (i32.const 0) (local.get 0x3c7))
+    (i64.store offset=0x3c8 align=1 (i32.const 0) (local.get 0x3c8))
+    (i64.store offset=0x3c9 align=1 (i32.const 0) (local.get 0x3c9))
+    (i64.store offset=0x3ca align=1 (i32.const 0) (local.get 0x3ca))
+    (i64.store offset=0x3cb align=1 (i32.const 0) (local.get 0x3cb))
+    (i64.store offset=0x3cc align=1 (i32.const 0) (local.get 0x3cc))
+    (i64.store offset=0x3cd align=1 (i32.const 0) (local.get 0x3cd))
+    (i64.store offset=0x3ce align=1 (i32.const 0) (local.get 0x3ce))
+    (i64.store offset=0x3cf align=1 (i32.const 0) (local.get 0x3cf))
+    (i64.store offset=0x3d0 align=1 (i32.const 0) (local.get 0x3d0))
+    (i64.store offset=0x3d1 align=1 (i32.const 0) (local.get 0x3d1))
+    (i64.store offset=0x3d2 align=1 (i32.const 0) (local.get 0x3d2))
+    (i64.store offset=0x3d3 align=1 (i32.const 0) (local.get 0x3d3))
+    (i64.store offset=0x3d4 align=1 (i32.const 0) (local.get 0x3d4))
+    (i64.store offset=0x3d5 align=1 (i32.const 0) (local.get 0x3d5))
+    (i64.store offset=0x3d6 align=1 (i32.const 0) (local.get 0x3d6))
+    (i64.store offset=0x3d7 align=1 (i32.const 0) (local.get 0x3d7))
+    (i64.store offset=0x3d8 align=1 (i32.const 0) (local.get 0x3d8))
+    (i64.store offset=0x3d9 align=1 (i32.const 0) (local.get 0x3d9))
+    (i64.store offset=0x3da align=1 (i32.const 0) (local.get 0x3da))
+    (i64.store offset=0x3db align=1 (i32.const 0) (local.get 0x3db))
+    (i64.store offset=0x3dc align=1 (i32.const 0) (local.get 0x3dc))
+    (i64.store offset=0x3dd align=1 (i32.const 0) (local.get 0x3dd))
+    (i64.store offset=0x3de align=1 (i32.const 0) (local.get 0x3de))
+    (i64.store offset=0x3df align=1 (i32.const 0) (local.get 0x3df))
+    (i64.store offset=0x3e0 align=1 (i32.const 0) (local.get 0x3e0))
+    (i64.store offset=0x3e1 align=1 (i32.const 0) (local.get 0x3e1))
+    (i64.store offset=0x3e2 align=1 (i32.const 0) (local.get 0x3e2))
+    (i64.store offset=0x3e3 align=1 (i32.const 0) (local.get 0x3e3))
+    (i64.store offset=0x3e4 align=1 (i32.const 0) (local.get 0x3e4))
+    (i64.store offset=0x3e5 align=1 (i32.const 0) (local.get 0x3e5))
+    (i64.store offset=0x3e6 align=1 (i32.const 0) (local.get 0x3e6))
+    (i64.store offset=0x3e7 align=1 (i32.const 0) (local.get 0x3e7))
+    (i64.store offset=0x3e8 align=1 (i32.const 0) (local.get 0x3e8))
+    (i64.store offset=0x3e9 align=1 (i32.const 0) (local.get 0x3e9))
+    (i64.store offset=0x3ea align=1 (i32.const 0) (local.get 0x3ea))
+    (i64.store offset=0x3eb align=1 (i32.const 0) (local.get 0x3eb))
+    (i64.store offset=0x3ec align=1 (i32.const 0) (local.get 0x3ec))
+    (i64.store offset=0x3ed align=1 (i32.const 0) (local.get 0x3ed))
+    (i64.store offset=0x3ee align=1 (i32.const 0) (local.get 0x3ee))
+    (i64.store offset=0x3ef align=1 (i32.const 0) (local.get 0x3ef))
+    (i64.store offset=0x3f0 align=1 (i32.const 0) (local.get 0x3f0))
+    (i64.store offset=0x3f1 align=1 (i32.const 0) (local.get 0x3f1))
+    (i64.store offset=0x3f2 align=1 (i32.const 0) (local.get 0x3f2))
+    (i64.store offset=0x3f3 align=1 (i32.const 0) (local.get 0x3f3))
+    (i64.store offset=0x3f4 align=1 (i32.const 0) (local.get 0x3f4))
+    (i64.store offset=0x3f5 align=1 (i32.const 0) (local.get 0x3f5))
+    (i64.store offset=0x3f6 align=1 (i32.const 0) (local.get 0x3f6))
+    (i64.store offset=0x3f7 align=1 (i32.const 0) (local.get 0x3f7))
+    (i64.store offset=0x3f8 align=1 (i32.const 0) (local.get 0x3f8))
+    (i64.store offset=0x3f9 align=1 (i32.const 0) (local.get 0x3f9))
+    (i64.store offset=0x3fa align=1 (i32.const 0) (local.get 0x3fa))
+    (i64.store offset=0x3fb align=1 (i32.const 0) (local.get 0x3fb))
+    (i64.store offset=0x3fc align=1 (i32.const 0) (local.get 0x3fc))
+    (i64.store offset=0x3fd align=1 (i32.const 0) (local.get 0x3fd))
+    (i64.store offset=0x3fe align=1 (i32.const 0) (local.get 0x3fe))
+    (i64.store offset=0x3ff align=1 (i32.const 0) (local.get 0x3ff))
+    (i64.store offset=0x400 align=1 (i32.const 0) (local.get 0x400))
+    (i64.store offset=0x401 align=1 (i32.const 0) (local.get 0x401))
+    (i64.store offset=0x402 align=1 (i32.const 0) (local.get 0x402))
+    (i64.store offset=0x403 align=1 (i32.const 0) (local.get 0x403))
+    (i64.store offset=0x404 align=1 (i32.const 0) (local.get 0x404))
+    (i64.store offset=0x405 align=1 (i32.const 0) (local.get 0x405))
+    (i64.store offset=0x406 align=1 (i32.const 0) (local.get 0x406))
+    (i64.store offset=0x407 align=1 (i32.const 0) (local.get 0x407))
+    (i64.store offset=0x408 align=1 (i32.const 0) (local.get 0x408))
+    (i64.store offset=0x409 align=1 (i32.const 0) (local.get 0x409))
+    (i64.store offset=0x40a align=1 (i32.const 0) (local.get 0x40a))
+    (i64.store offset=0x40b align=1 (i32.const 0) (local.get 0x40b))
+    (i64.store offset=0x40c align=1 (i32.const 0) (local.get 0x40c))
+    (i64.store offset=0x40d align=1 (i32.const 0) (local.get 0x40d))
+    (i64.store offset=0x40e align=1 (i32.const 0) (local.get 0x40e))
+    (i64.store offset=0x40f align=1 (i32.const 0) (local.get 0x40f))
+    (i64.store offset=0x410 align=1 (i32.const 0) (local.get 0x410))
+    (i64.store offset=0x411 align=1 (i32.const 0) (local.get 0x411))
+    (i64.store offset=0x412 align=1 (i32.const 0) (local.get 0x412))
+    (i64.store offset=0x413 align=1 (i32.const 0) (local.get 0x413))
+    (i64.store offset=0x414 align=1 (i32.const 0) (local.get 0x414))
+    (i64.store offset=0x415 align=1 (i32.const 0) (local.get 0x415))
+    (i64.store offset=0x416 align=1 (i32.const 0) (local.get 0x416))
+    (i64.store offset=0x417 align=1 (i32.const 0) (local.get 0x417))
+    (i64.store offset=0x418 align=1 (i32.const 0) (local.get 0x418))
+    (i64.store offset=0x419 align=1 (i32.const 0) (local.get 0x419))
+    (i64.store offset=0x41a align=1 (i32.const 0) (local.get 0x41a))
+    (i64.store offset=0x41b align=1 (i32.const 0) (local.get 0x41b))
+    (i64.store offset=0x41c align=1 (i32.const 0) (local.get 0x41c))
+    (i64.store offset=0x41d align=1 (i32.const 0) (local.get 0x41d))
+    (i64.store offset=0x41e align=1 (i32.const 0) (local.get 0x41e))
+    (i64.store offset=0x41f align=1 (i32.const 0) (local.get 0x41f))
+  )
+)`);
+
+// ./test/core/skip-stack-guard-page.wast:2275
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [0]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2276
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [100]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2277
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [200]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2278
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [300]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2279
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [400]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2280
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [500]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2281
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [600]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2282
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [700]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2283
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [800]), `call stack exhausted`);
+
+// ./test/core/skip-stack-guard-page.wast:2284
+assert_exhaustion(() => invoke($0, `test-guard-page-skip`, [900]), `call stack exhausted`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/stack.wast.js b/js/src/jit-test/tests/wasm/spec/spec/stack.wast.js
new file mode 100644
index 0000000000..306a613cf8
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/stack.wast.js
@@ -0,0 +1,263 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/stack.wast
+
+// ./test/core/stack.wast:1
+let $0 = instantiate(`(module
+  (func (export "fac-expr") (param $$n i64) (result i64)
+    (local $$i i64)
+    (local $$res i64)
+    (local.set $$i (local.get $$n))
+    (local.set $$res (i64.const 1))
+    (block $$done
+      (loop $$loop
+        (if
+          (i64.eq (local.get $$i) (i64.const 0))
+          (then (br $$done))
+          (else
+            (local.set $$res (i64.mul (local.get $$i) (local.get $$res)))
+            (local.set $$i (i64.sub (local.get $$i) (i64.const 1)))
+          )
+        )
+        (br $$loop)
+      )
+    )
+    (local.get $$res)
+  )
+
+  (func (export "fac-stack") (param $$n i64) (result i64)
+    (local $$i i64)
+    (local $$res i64)
+    (local.get $$n)
+    (local.set $$i)
+    (i64.const 1)
+    (local.set $$res)
+    (block $$done
+      (loop $$loop
+        (local.get $$i)
+        (i64.const 0)
+        (i64.eq)
+        (if
+          (then (br $$done))
+          (else
+            (local.get $$i)
+            (local.get $$res)
+            (i64.mul)
+            (local.set $$res)
+            (local.get $$i)
+            (i64.const 1)
+            (i64.sub)
+            (local.set $$i)
+          )
+        )
+        (br $$loop)
+      )
+    )
+    (local.get $$res)
+  )
+
+  (func (export "fac-stack-raw") (param $$n i64) (result i64)
+    (local $$i i64)
+    (local $$res i64)
+    local.get $$n
+    local.set $$i
+    i64.const 1
+    local.set $$res
+    block $$done
+      loop $$loop
+        local.get $$i
+        i64.const 0
+        i64.eq
+        if $$body
+          br $$done
+        else $$body
+          local.get $$i
+          local.get $$res
+          i64.mul
+          local.set $$res
+          local.get $$i
+          i64.const 1
+          i64.sub
+          local.set $$i
+        end $$body
+        br $$loop
+      end $$loop
+    end $$done
+    local.get $$res
+  )
+
+  (func (export "fac-mixed") (param $$n i64) (result i64)
+    (local $$i i64)
+    (local $$res i64)
+    (local.set $$i (local.get $$n))
+    (local.set $$res (i64.const 1))
+    (block $$done
+      (loop $$loop
+        (i64.eq (local.get $$i) (i64.const 0))
+        (if
+          (then (br $$done))
+          (else
+            (i64.mul (local.get $$i) (local.get $$res))
+            (local.set $$res)
+            (i64.sub (local.get $$i) (i64.const 1))
+            (local.set $$i)
+          )
+        )
+        (br $$loop)
+      )
+    )
+    (local.get $$res)
+  )
+
+  (func (export "fac-mixed-raw") (param $$n i64) (result i64)
+    (local $$i i64)
+    (local $$res i64)
+    (local.set $$i (local.get $$n))
+    (local.set $$res (i64.const 1))
+    block $$done
+      loop $$loop
+        (i64.eq (local.get $$i) (i64.const 0))
+        if
+          br $$done
+        else
+          (i64.mul (local.get $$i) (local.get $$res))
+          local.set $$res
+          (i64.sub (local.get $$i) (i64.const 1))
+          local.set $$i
+        end
+        br $$loop
+      end
+    end
+    local.get $$res
+  )
+
+  (global $$temp (mut i32) (i32.const 0))
+  (func $$add_one_to_global (result i32)
+    (local i32)
+    (global.set $$temp (i32.add (i32.const 1) (global.get $$temp)))
+    (global.get $$temp)
+  )
+  (func $$add_one_to_global_and_drop
+    (drop (call $$add_one_to_global))
+  )
+  (func (export "not-quite-a-tree") (result i32)
+    call $$add_one_to_global
+    call $$add_one_to_global
+    call $$add_one_to_global_and_drop
+    i32.add
+  )
+)`);
+
+// ./test/core/stack.wast:146
+assert_return(() => invoke($0, `fac-expr`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/stack.wast:147
+assert_return(() => invoke($0, `fac-stack`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/stack.wast:148
+assert_return(() => invoke($0, `fac-mixed`, [25n]), [value("i64", 7034535277573963776n)]);
+
+// ./test/core/stack.wast:150
+assert_return(() => invoke($0, `not-quite-a-tree`, []), [value("i32", 3)]);
+
+// ./test/core/stack.wast:151
+assert_return(() => invoke($0, `not-quite-a-tree`, []), [value("i32", 9)]);
+
+// ./test/core/stack.wast:156
+let $1 = instantiate(`(module
+  (type $$proc (func))
+  (table 1 funcref)
+
+  (func
+    (block i32.const 0 call_indirect)
+    (loop i32.const 0 call_indirect)
+    (if (i32.const 0) (then i32.const 0 call_indirect))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect)
+      (else i32.const 0 call_indirect)
+    )
+    (block i32.const 0 call_indirect (type $$proc))
+    (loop i32.const 0 call_indirect (type $$proc))
+    (if (i32.const 0) (then i32.const 0 call_indirect (type $$proc)))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $$proc))
+      (else i32.const 0 call_indirect (type $$proc))
+    )
+    (block i32.const 0 i32.const 0 call_indirect (param i32))
+    (loop i32.const 0 i32.const 0 call_indirect (param i32))
+    (if (i32.const 0) (then i32.const 0 i32.const 0 call_indirect (param i32)))
+    (if (i32.const 0)
+      (then i32.const 0 i32.const 0 call_indirect (param i32))
+      (else i32.const 0 i32.const 0 call_indirect (param i32))
+    )
+    (block (result i32) i32.const 0 call_indirect (result i32)) (drop)
+    (loop (result i32) i32.const 0 call_indirect (result i32)) (drop)
+    (if (result i32) (i32.const 0)
+      (then i32.const 0 call_indirect (result i32))
+      (else i32.const 0 call_indirect (result i32))
+    ) (drop)
+    (block i32.const 0 call_indirect (type $$proc) (param) (result))
+    (loop i32.const 0 call_indirect (type $$proc) (param) (result))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $$proc) (param) (result))
+    )
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $$proc) (param) (param) (result))
+      (else i32.const 0 call_indirect (type $$proc) (param) (result) (result))
+    )
+
+    block i32.const 0 call_indirect end
+    loop i32.const 0 call_indirect end
+    i32.const 0 if i32.const 0 call_indirect end
+    i32.const 0 if i32.const 0 call_indirect else i32.const 0 call_indirect end
+    block i32.const 0 call_indirect (type $$proc) end
+    loop i32.const 0 call_indirect (type $$proc) end
+    i32.const 0 if i32.const 0 call_indirect (type $$proc) end
+    i32.const 0
+    if
+      i32.const 0 call_indirect (type $$proc)
+    else
+      i32.const 0 call_indirect (type $$proc)
+    end
+    block i32.const 0 i32.const 0 call_indirect (param i32) end
+    loop i32.const 0 i32.const 0 call_indirect (param i32) end
+    i32.const 0 if i32.const 0 i32.const 0 call_indirect (param i32) end
+    i32.const 0
+    if
+      i32.const 0 i32.const 0 call_indirect (param i32)
+    else
+      i32.const 0 i32.const 0 call_indirect (param i32)
+    end
+    block (result i32) i32.const 0 call_indirect (result i32) end drop
+    loop (result i32) i32.const 0 call_indirect (result i32) end drop
+    i32.const 0
+    if (result i32)
+      i32.const 0 call_indirect (result i32)
+    else
+      i32.const 0 call_indirect (result i32)
+    end drop
+    block i32.const 0 call_indirect (type $$proc) (param) (result) end
+    loop i32.const 0 call_indirect (type $$proc) (param) (result) end
+    i32.const 0 if i32.const 0 call_indirect (type $$proc) (param) (result) end
+    i32.const 0
+    if
+      i32.const 0 call_indirect (type $$proc) (param) (result)
+    else
+      i32.const 0 call_indirect (type $$proc) (param) (param) (result) (result)
+    end
+    i32.const 0 call_indirect
+  )
+)`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/start.wast.js b/js/src/jit-test/tests/wasm/spec/spec/start.wast.js
new file mode 100644
index 0000000000..7dee026a84
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/start.wast.js
@@ -0,0 +1,150 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/start.wast
+
+// ./test/core/start.wast:1
+assert_invalid(() => instantiate(`(module (func) (start 1))`), `unknown function`);
+
+// ./test/core/start.wast:6
+assert_invalid(
+  () => instantiate(`(module
+    (func $$main (result i32) (return (i32.const 0)))
+    (start $$main)
+  )`),
+  `start function`,
+);
+
+// ./test/core/start.wast:13
+assert_invalid(
+  () => instantiate(`(module
+    (func $$main (param $$a i32))
+    (start $$main)
+  )`),
+  `start function`,
+);
+
+// ./test/core/start.wast:21
+let $0 = instantiate(`(module
+  (memory (data "A"))
+  (func $$inc
+    (i32.store8
+      (i32.const 0)
+      (i32.add
+        (i32.load8_u (i32.const 0))
+        (i32.const 1)
+      )
+    )
+  )
+  (func $$get (result i32)
+    (return (i32.load8_u (i32.const 0)))
+  )
+  (func $$main
+    (call $$inc)
+    (call $$inc)
+    (call $$inc)
+  )
+
+  (start $$main)
+  (export "inc" (func $$inc))
+  (export "get" (func $$get))
+)`);
+
+// ./test/core/start.wast:45
+assert_return(() => invoke($0, `get`, []), [value("i32", 68)]);
+
+// ./test/core/start.wast:46
+invoke($0, `inc`, []);
+
+// ./test/core/start.wast:47
+assert_return(() => invoke($0, `get`, []), [value("i32", 69)]);
+
+// ./test/core/start.wast:48
+invoke($0, `inc`, []);
+
+// ./test/core/start.wast:49
+assert_return(() => invoke($0, `get`, []), [value("i32", 70)]);
+
+// ./test/core/start.wast:51
+let $1 = instantiate(`(module
+  (memory (data "A"))
+  (func $$inc
+    (i32.store8
+      (i32.const 0)
+      (i32.add
+        (i32.load8_u (i32.const 0))
+        (i32.const 1)
+      )
+    )
+  )
+  (func $$get (result i32)
+    (return (i32.load8_u (i32.const 0)))
+  )
+  (func $$main
+    (call $$inc)
+    (call $$inc)
+    (call $$inc)
+  )
+  (start 2)
+  (export "inc" (func $$inc))
+  (export "get" (func $$get))
+)`);
+
+// ./test/core/start.wast:74
+assert_return(() => invoke($1, `get`, []), [value("i32", 68)]);
+
+// ./test/core/start.wast:75
+invoke($1, `inc`, []);
+
+// ./test/core/start.wast:76
+assert_return(() => invoke($1, `get`, []), [value("i32", 69)]);
+
+// ./test/core/start.wast:77
+invoke($1, `inc`, []);
+
+// ./test/core/start.wast:78
+assert_return(() => invoke($1, `get`, []), [value("i32", 70)]);
+
+// ./test/core/start.wast:80
+let $2 = instantiate(`(module
+  (func $$print_i32 (import "spectest" "print_i32") (param i32))
+  (func $$main (call $$print_i32 (i32.const 1)))
+  (start 1)
+)`);
+
+// ./test/core/start.wast:86
+let $3 = instantiate(`(module
+  (func $$print_i32 (import "spectest" "print_i32") (param i32))
+  (func $$main (call $$print_i32 (i32.const 2)))
+  (start $$main)
+)`);
+
+// ./test/core/start.wast:92
+let $4 = instantiate(`(module
+  (func $$print (import "spectest" "print"))
+  (start $$print)
+)`);
+
+// ./test/core/start.wast:97
+assert_trap(
+  () => instantiate(`(module (func $$main (unreachable)) (start $$main))`),
+  `unreachable`,
+);
+
+// ./test/core/start.wast:102
+assert_malformed(
+  () => instantiate(`(module (func $$a (unreachable)) (func $$b (unreachable)) (start $$a) (start $$b)) `),
+  `multiple start sections`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/store.wast.js b/js/src/jit-test/tests/wasm/spec/spec/store.wast.js
new file mode 100644
index 0000000000..c11b459ca2
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/store.wast.js
@@ -0,0 +1,583 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/store.wast
+
+// ./test/core/store.wast:3
+let $0 = instantiate(`(module
+  (memory 1)
+
+  (func (export "as-block-value")
+    (block (i32.store (i32.const 0) (i32.const 1)))
+  )
+  (func (export "as-loop-value")
+    (loop (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-br-value")
+    (block (br 0 (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (i32.store (i32.const 0) (i32.const 1)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value")
+    (return (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (i32.store (i32.const 0) (i32.const 1))))
+  )
+)`);
+
+// ./test/core/store.wast:44
+assert_return(() => invoke($0, `as-block-value`, []), []);
+
+// ./test/core/store.wast:45
+assert_return(() => invoke($0, `as-loop-value`, []), []);
+
+// ./test/core/store.wast:47
+assert_return(() => invoke($0, `as-br-value`, []), []);
+
+// ./test/core/store.wast:48
+assert_return(() => invoke($0, `as-br_if-value`, []), []);
+
+// ./test/core/store.wast:49
+assert_return(() => invoke($0, `as-br_if-value-cond`, []), []);
+
+// ./test/core/store.wast:50
+assert_return(() => invoke($0, `as-br_table-value`, []), []);
+
+// ./test/core/store.wast:52
+assert_return(() => invoke($0, `as-return-value`, []), []);
+
+// ./test/core/store.wast:54
+assert_return(() => invoke($0, `as-if-then`, []), []);
+
+// ./test/core/store.wast:55
+assert_return(() => invoke($0, `as-if-else`, []), []);
+
+// ./test/core/store.wast:57
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (i32.store32 (local.get 0) (i32.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:64
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (i32.store64 (local.get 0) (i64.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:72
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (i64.store64 (local.get 0) (i64.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:80
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (f32.store32 (local.get 0) (f32.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:87
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (f32.store64 (local.get 0) (f64.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:95
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (f64.store32 (local.get 0) (f32.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:102
+assert_malformed(
+  () => instantiate(`(memory 1) (func (param i32) (f64.store64 (local.get 0) (f64.const 0))) `),
+  `unknown operator`,
+);
+
+// ./test/core/store.wast:111
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:115
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:119
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:123
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:127
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:131
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:135
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:139
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:143
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:149
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty
+      (i32.store)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:158
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty
+     (i32.const 0) (i32.store)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:167
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.store))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:177
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.store))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:187
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.store))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:197
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.store))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:207
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:217
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-then
+      (i32.const 0)
+      (if (then (i32.const 0) (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:227
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:237
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-else
+      (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.const 0) (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:247
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-br
+      (i32.const 0) (i32.const 0)
+      (block (br 0 (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:257
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.const 0) (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:267
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-br_if
+      (i32.const 0) (i32.const 0)
+      (block (br_if 0 (i32.store) (i32.const 1)) )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:277
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.const 0) (i32.store) (i32.const 1)) )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:287
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-br_table
+      (i32.const 0) (i32.const 0)
+      (block (br_table 0 (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:297
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.const 0) (i32.store)))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:307
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-return
+      (return (i32.store))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:316
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-return
+      (return (i32.const 0) (i32.store))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:325
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-select
+      (select (i32.store) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:334
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-select
+      (select (i32.const 0) (i32.store) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:343
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-address-empty-in-call
+      (call 1 (i32.store))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:353
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$type-value-empty-in-call
+      (call 1 (i32.const 0) (i32.store))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:363
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-address-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.store) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:379
+assert_invalid(
+  () => instantiate(`(module
+    (memory 1)
+    (func $$f (param i32) (result i32) (local.get 0))
+    (type $$sig (func (param i32) (result i32)))
+    (table funcref (elem $$f))
+    (func $$type-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $$sig)
+          (i32.const 0) (i32.store) (i32.const 0)
+        )
+      )
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:399
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i32.store (f32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:400
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i32.store8 (f32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:401
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i32.store16 (f32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:402
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store (f32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:403
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store8 (f32.const 0) (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:404
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store16 (f32.const 0) (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:405
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store32 (f32.const 0) (i64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:406
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (f32.store (f32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:407
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (f64.store (f32.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:409
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i32.store (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:410
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i32.store8 (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:411
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i32.store16 (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:412
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store (i32.const 0) (f32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:413
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store8 (i32.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:414
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store16 (i32.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:415
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (i64.store32 (i32.const 0) (f64.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:416
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (f32.store (i32.const 0) (i32.const 0))))`),
+  `type mismatch`,
+);
+
+// ./test/core/store.wast:417
+assert_invalid(
+  () => instantiate(`(module (memory 1) (func (f64.store (i32.const 0) (i64.const 0))))`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/switch.wast.js b/js/src/jit-test/tests/wasm/spec/spec/switch.wast.js
new file mode 100644
index 0000000000..403b2c3762
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/switch.wast.js
@@ -0,0 +1,220 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/switch.wast
+
+// ./test/core/switch.wast:1
+let $0 = instantiate(`(module
+  ;; Statement switch
+  (func (export "stmt") (param $$i i32) (result i32)
+    (local $$j i32)
+    (local.set $$j (i32.const 100))
+    (block $$switch
+      (block $$7
+        (block $$default
+          (block $$6
+            (block $$5
+              (block $$4
+                (block $$3
+                  (block $$2
+                    (block $$1
+                      (block $$0
+                        (br_table $$0 $$1 $$2 $$3 $$4 $$5 $$6 $$7 $$default
+                          (local.get $$i)
+                        )
+                      ) ;; 0
+                      (return (local.get $$i))
+                    ) ;; 1
+                    (nop)
+                    ;; fallthrough
+                  ) ;; 2
+                  ;; fallthrough
+                ) ;; 3
+                (local.set $$j (i32.sub (i32.const 0) (local.get $$i)))
+                (br $$switch)
+              ) ;; 4
+              (br $$switch)
+            ) ;; 5
+            (local.set $$j (i32.const 101))
+            (br $$switch)
+          ) ;; 6
+          (local.set $$j (i32.const 101))
+          ;; fallthrough
+        ) ;; default
+        (local.set $$j (i32.const 102))
+      ) ;; 7
+      ;; fallthrough
+    )
+    (return (local.get $$j))
+  )
+
+  ;; Expression switch
+  (func (export "expr") (param $$i i64) (result i64)
+    (local $$j i64)
+    (local.set $$j (i64.const 100))
+    (return
+      (block $$switch (result i64)
+        (block $$7
+          (block $$default
+            (block $$4
+              (block $$5
+                (block $$6
+                  (block $$3
+                    (block $$2
+                      (block $$1
+                        (block $$0
+                          (br_table $$0 $$1 $$2 $$3 $$4 $$5 $$6 $$7 $$default
+                            (i32.wrap_i64 (local.get $$i))
+                          )
+                        ) ;; 0
+                        (return (local.get $$i))
+                      ) ;; 1
+                      (nop)
+                      ;; fallthrough
+                    ) ;; 2
+                    ;; fallthrough
+                  ) ;; 3
+                  (br $$switch (i64.sub (i64.const 0) (local.get $$i)))
+                ) ;; 6
+                (local.set $$j (i64.const 101))
+                ;; fallthrough
+              ) ;; 4
+              ;; fallthrough
+            ) ;; 5
+            ;; fallthrough
+          ) ;; default
+          (br $$switch (local.get $$j))
+        ) ;; 7
+        (i64.const -5)
+      )
+    )
+  )
+
+  ;; Argument switch
+  (func (export "arg") (param $$i i32) (result i32)
+    (return
+      (block $$2 (result i32)
+        (i32.add (i32.const 10)
+          (block $$1 (result i32)
+            (i32.add (i32.const 100)
+              (block $$0 (result i32)
+                (i32.add (i32.const 1000)
+                  (block $$default (result i32)
+                    (br_table $$0 $$1 $$2 $$default
+                      (i32.mul (i32.const 2) (local.get $$i))
+                      (i32.and (i32.const 3) (local.get $$i))
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; Corner cases
+  (func (export "corner") (result i32)
+    (block
+      (br_table 0 (i32.const 0))
+    )
+    (i32.const 1)
+  )
+)`);
+
+// ./test/core/switch.wast:120
+assert_return(() => invoke($0, `stmt`, [0]), [value("i32", 0)]);
+
+// ./test/core/switch.wast:121
+assert_return(() => invoke($0, `stmt`, [1]), [value("i32", -1)]);
+
+// ./test/core/switch.wast:122
+assert_return(() => invoke($0, `stmt`, [2]), [value("i32", -2)]);
+
+// ./test/core/switch.wast:123
+assert_return(() => invoke($0, `stmt`, [3]), [value("i32", -3)]);
+
+// ./test/core/switch.wast:124
+assert_return(() => invoke($0, `stmt`, [4]), [value("i32", 100)]);
+
+// ./test/core/switch.wast:125
+assert_return(() => invoke($0, `stmt`, [5]), [value("i32", 101)]);
+
+// ./test/core/switch.wast:126
+assert_return(() => invoke($0, `stmt`, [6]), [value("i32", 102)]);
+
+// ./test/core/switch.wast:127
+assert_return(() => invoke($0, `stmt`, [7]), [value("i32", 100)]);
+
+// ./test/core/switch.wast:128
+assert_return(() => invoke($0, `stmt`, [-10]), [value("i32", 102)]);
+
+// ./test/core/switch.wast:130
+assert_return(() => invoke($0, `expr`, [0n]), [value("i64", 0n)]);
+
+// ./test/core/switch.wast:131
+assert_return(() => invoke($0, `expr`, [1n]), [value("i64", -1n)]);
+
+// ./test/core/switch.wast:132
+assert_return(() => invoke($0, `expr`, [2n]), [value("i64", -2n)]);
+
+// ./test/core/switch.wast:133
+assert_return(() => invoke($0, `expr`, [3n]), [value("i64", -3n)]);
+
+// ./test/core/switch.wast:134
+assert_return(() => invoke($0, `expr`, [6n]), [value("i64", 101n)]);
+
+// ./test/core/switch.wast:135
+assert_return(() => invoke($0, `expr`, [7n]), [value("i64", -5n)]);
+
+// ./test/core/switch.wast:136
+assert_return(() => invoke($0, `expr`, [-10n]), [value("i64", 100n)]);
+
+// ./test/core/switch.wast:138
+assert_return(() => invoke($0, `arg`, [0]), [value("i32", 110)]);
+
+// ./test/core/switch.wast:139
+assert_return(() => invoke($0, `arg`, [1]), [value("i32", 12)]);
+
+// ./test/core/switch.wast:140
+assert_return(() => invoke($0, `arg`, [2]), [value("i32", 4)]);
+
+// ./test/core/switch.wast:141
+assert_return(() => invoke($0, `arg`, [3]), [value("i32", 1116)]);
+
+// ./test/core/switch.wast:142
+assert_return(() => invoke($0, `arg`, [4]), [value("i32", 118)]);
+
+// ./test/core/switch.wast:143
+assert_return(() => invoke($0, `arg`, [5]), [value("i32", 20)]);
+
+// ./test/core/switch.wast:144
+assert_return(() => invoke($0, `arg`, [6]), [value("i32", 12)]);
+
+// ./test/core/switch.wast:145
+assert_return(() => invoke($0, `arg`, [7]), [value("i32", 1124)]);
+
+// ./test/core/switch.wast:146
+assert_return(() => invoke($0, `arg`, [8]), [value("i32", 126)]);
+
+// ./test/core/switch.wast:148
+assert_return(() => invoke($0, `corner`, []), [value("i32", 1)]);
+
+// ./test/core/switch.wast:150
+assert_invalid(
+  () => instantiate(`(module (func (br_table 3 (i32.const 0))))`),
+  `unknown label`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table-sub.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table-sub.wast.js
new file mode 100644
index 0000000000..81357fa888
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table-sub.wast.js
@@ -0,0 +1,40 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table-sub.wast
+
+// ./test/core/table-sub.wast:1
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 10 funcref)
+    (table $$t2 10 externref)
+    (func $$f
+      (table.copy $$t1 $$t2 (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table-sub.wast:12
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 funcref)
+    (elem $$el externref)
+    (func $$f
+      (table.init $$t $$el (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_copy.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_copy.wast.js
new file mode 100644
index 0000000000..d78f54181c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_copy.wast.js
@@ -0,0 +1,6436 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_copy.wast
+
+// ./test/core/table_copy.wast:6
+let $0 = instantiate(`(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)`);
+
+// ./test/core/table_copy.wast:13
+register($0, `a`);
+
+// ./test/core/table_copy.wast:15
+let $1 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:45
+invoke($1, `test`, []);
+
+// ./test/core/table_copy.wast:46
+assert_trap(() => invoke($1, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:47
+assert_trap(() => invoke($1, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:48
+assert_return(() => invoke($1, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:49
+assert_return(() => invoke($1, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:50
+assert_return(() => invoke($1, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:51
+assert_return(() => invoke($1, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:52
+assert_trap(() => invoke($1, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:53
+assert_trap(() => invoke($1, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:54
+assert_trap(() => invoke($1, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:55
+assert_trap(() => invoke($1, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:56
+assert_trap(() => invoke($1, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:57
+assert_trap(() => invoke($1, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:58
+assert_return(() => invoke($1, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:59
+assert_return(() => invoke($1, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:60
+assert_return(() => invoke($1, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:61
+assert_return(() => invoke($1, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:62
+assert_return(() => invoke($1, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:63
+assert_trap(() => invoke($1, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:64
+assert_trap(() => invoke($1, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:65
+assert_trap(() => invoke($1, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:66
+assert_trap(() => invoke($1, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:67
+assert_trap(() => invoke($1, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:68
+assert_trap(() => invoke($1, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:69
+assert_trap(() => invoke($1, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:70
+assert_trap(() => invoke($1, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:71
+assert_trap(() => invoke($1, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:72
+assert_trap(() => invoke($1, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:73
+assert_trap(() => invoke($1, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:74
+assert_trap(() => invoke($1, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:75
+assert_trap(() => invoke($1, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:76
+assert_trap(() => invoke($1, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:77
+assert_trap(() => invoke($1, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:78
+assert_trap(() => invoke($1, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:79
+assert_return(() => invoke($1, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:80
+assert_return(() => invoke($1, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:81
+assert_return(() => invoke($1, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:82
+assert_return(() => invoke($1, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:83
+assert_trap(() => invoke($1, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:84
+assert_trap(() => invoke($1, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:85
+assert_trap(() => invoke($1, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:86
+assert_trap(() => invoke($1, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:87
+assert_return(() => invoke($1, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:88
+assert_return(() => invoke($1, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:89
+assert_return(() => invoke($1, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:90
+assert_return(() => invoke($1, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:91
+assert_return(() => invoke($1, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:92
+assert_trap(() => invoke($1, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:93
+assert_trap(() => invoke($1, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:94
+assert_trap(() => invoke($1, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:95
+assert_trap(() => invoke($1, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:96
+assert_trap(() => invoke($1, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:97
+assert_trap(() => invoke($1, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:98
+assert_trap(() => invoke($1, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:99
+assert_trap(() => invoke($1, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:100
+assert_trap(() => invoke($1, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:101
+assert_trap(() => invoke($1, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:102
+assert_trap(() => invoke($1, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:103
+assert_trap(() => invoke($1, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:104
+assert_trap(() => invoke($1, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:105
+assert_trap(() => invoke($1, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:107
+let $2 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:137
+invoke($2, `test`, []);
+
+// ./test/core/table_copy.wast:138
+assert_trap(() => invoke($2, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:139
+assert_trap(() => invoke($2, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:140
+assert_return(() => invoke($2, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:141
+assert_return(() => invoke($2, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:142
+assert_return(() => invoke($2, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:143
+assert_return(() => invoke($2, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:144
+assert_trap(() => invoke($2, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:145
+assert_trap(() => invoke($2, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:146
+assert_trap(() => invoke($2, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:147
+assert_trap(() => invoke($2, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:148
+assert_trap(() => invoke($2, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:149
+assert_trap(() => invoke($2, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:150
+assert_return(() => invoke($2, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:151
+assert_return(() => invoke($2, `check_t0`, [13]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:152
+assert_return(() => invoke($2, `check_t0`, [14]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:153
+assert_return(() => invoke($2, `check_t0`, [15]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:154
+assert_return(() => invoke($2, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:155
+assert_trap(() => invoke($2, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:156
+assert_trap(() => invoke($2, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:157
+assert_trap(() => invoke($2, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:158
+assert_trap(() => invoke($2, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:159
+assert_trap(() => invoke($2, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:160
+assert_trap(() => invoke($2, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:161
+assert_trap(() => invoke($2, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:162
+assert_trap(() => invoke($2, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:163
+assert_trap(() => invoke($2, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:164
+assert_trap(() => invoke($2, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:165
+assert_trap(() => invoke($2, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:166
+assert_trap(() => invoke($2, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:167
+assert_trap(() => invoke($2, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:168
+assert_trap(() => invoke($2, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:169
+assert_trap(() => invoke($2, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:170
+assert_trap(() => invoke($2, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:171
+assert_return(() => invoke($2, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:172
+assert_return(() => invoke($2, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:173
+assert_return(() => invoke($2, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:174
+assert_return(() => invoke($2, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:175
+assert_trap(() => invoke($2, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:176
+assert_trap(() => invoke($2, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:177
+assert_trap(() => invoke($2, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:178
+assert_trap(() => invoke($2, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:179
+assert_return(() => invoke($2, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:180
+assert_return(() => invoke($2, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:181
+assert_return(() => invoke($2, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:182
+assert_return(() => invoke($2, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:183
+assert_return(() => invoke($2, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:184
+assert_trap(() => invoke($2, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:185
+assert_trap(() => invoke($2, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:186
+assert_trap(() => invoke($2, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:187
+assert_trap(() => invoke($2, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:188
+assert_trap(() => invoke($2, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:189
+assert_trap(() => invoke($2, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:190
+assert_trap(() => invoke($2, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:191
+assert_trap(() => invoke($2, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:192
+assert_trap(() => invoke($2, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:193
+assert_trap(() => invoke($2, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:194
+assert_trap(() => invoke($2, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:195
+assert_trap(() => invoke($2, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:196
+assert_trap(() => invoke($2, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:197
+assert_trap(() => invoke($2, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:199
+let $3 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:229
+invoke($3, `test`, []);
+
+// ./test/core/table_copy.wast:230
+assert_trap(() => invoke($3, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:231
+assert_trap(() => invoke($3, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:232
+assert_return(() => invoke($3, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:233
+assert_return(() => invoke($3, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:234
+assert_return(() => invoke($3, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:235
+assert_return(() => invoke($3, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:236
+assert_trap(() => invoke($3, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:237
+assert_trap(() => invoke($3, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:238
+assert_trap(() => invoke($3, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:239
+assert_trap(() => invoke($3, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:240
+assert_trap(() => invoke($3, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:241
+assert_trap(() => invoke($3, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:242
+assert_return(() => invoke($3, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:243
+assert_return(() => invoke($3, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:244
+assert_return(() => invoke($3, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:245
+assert_return(() => invoke($3, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:246
+assert_return(() => invoke($3, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:247
+assert_trap(() => invoke($3, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:248
+assert_trap(() => invoke($3, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:249
+assert_trap(() => invoke($3, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:250
+assert_trap(() => invoke($3, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:251
+assert_trap(() => invoke($3, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:252
+assert_trap(() => invoke($3, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:253
+assert_trap(() => invoke($3, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:254
+assert_trap(() => invoke($3, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:255
+assert_return(() => invoke($3, `check_t0`, [25]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:256
+assert_return(() => invoke($3, `check_t0`, [26]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:257
+assert_trap(() => invoke($3, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:258
+assert_trap(() => invoke($3, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:259
+assert_trap(() => invoke($3, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:260
+assert_trap(() => invoke($3, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:261
+assert_trap(() => invoke($3, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:262
+assert_trap(() => invoke($3, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:263
+assert_return(() => invoke($3, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:264
+assert_return(() => invoke($3, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:265
+assert_return(() => invoke($3, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:266
+assert_return(() => invoke($3, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:267
+assert_trap(() => invoke($3, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:268
+assert_trap(() => invoke($3, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:269
+assert_trap(() => invoke($3, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:270
+assert_trap(() => invoke($3, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:271
+assert_return(() => invoke($3, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:272
+assert_return(() => invoke($3, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:273
+assert_return(() => invoke($3, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:274
+assert_return(() => invoke($3, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:275
+assert_return(() => invoke($3, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:276
+assert_trap(() => invoke($3, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:277
+assert_trap(() => invoke($3, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:278
+assert_trap(() => invoke($3, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:279
+assert_trap(() => invoke($3, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:280
+assert_trap(() => invoke($3, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:281
+assert_trap(() => invoke($3, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:282
+assert_trap(() => invoke($3, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:283
+assert_trap(() => invoke($3, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:284
+assert_trap(() => invoke($3, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:285
+assert_trap(() => invoke($3, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:286
+assert_trap(() => invoke($3, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:287
+assert_trap(() => invoke($3, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:288
+assert_trap(() => invoke($3, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:289
+assert_trap(() => invoke($3, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:291
+let $4 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:321
+invoke($4, `test`, []);
+
+// ./test/core/table_copy.wast:322
+assert_trap(() => invoke($4, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:323
+assert_trap(() => invoke($4, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:324
+assert_return(() => invoke($4, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:325
+assert_return(() => invoke($4, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:326
+assert_return(() => invoke($4, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:327
+assert_return(() => invoke($4, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:328
+assert_trap(() => invoke($4, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:329
+assert_trap(() => invoke($4, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:330
+assert_trap(() => invoke($4, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:331
+assert_trap(() => invoke($4, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:332
+assert_trap(() => invoke($4, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:333
+assert_trap(() => invoke($4, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:334
+assert_return(() => invoke($4, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:335
+assert_trap(() => invoke($4, `check_t0`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:336
+assert_trap(() => invoke($4, `check_t0`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:337
+assert_trap(() => invoke($4, `check_t0`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:338
+assert_return(() => invoke($4, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:339
+assert_trap(() => invoke($4, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:340
+assert_trap(() => invoke($4, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:341
+assert_trap(() => invoke($4, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:342
+assert_trap(() => invoke($4, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:343
+assert_trap(() => invoke($4, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:344
+assert_trap(() => invoke($4, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:345
+assert_trap(() => invoke($4, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:346
+assert_trap(() => invoke($4, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:347
+assert_trap(() => invoke($4, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:348
+assert_trap(() => invoke($4, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:349
+assert_trap(() => invoke($4, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:350
+assert_trap(() => invoke($4, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:351
+assert_trap(() => invoke($4, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:352
+assert_trap(() => invoke($4, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:353
+assert_trap(() => invoke($4, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:354
+assert_trap(() => invoke($4, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:355
+assert_return(() => invoke($4, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:356
+assert_return(() => invoke($4, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:357
+assert_return(() => invoke($4, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:358
+assert_return(() => invoke($4, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:359
+assert_trap(() => invoke($4, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:360
+assert_trap(() => invoke($4, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:361
+assert_trap(() => invoke($4, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:362
+assert_trap(() => invoke($4, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:363
+assert_return(() => invoke($4, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:364
+assert_return(() => invoke($4, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:365
+assert_return(() => invoke($4, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:366
+assert_return(() => invoke($4, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:367
+assert_return(() => invoke($4, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:368
+assert_trap(() => invoke($4, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:369
+assert_trap(() => invoke($4, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:370
+assert_trap(() => invoke($4, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:371
+assert_trap(() => invoke($4, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:372
+assert_trap(() => invoke($4, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:373
+assert_trap(() => invoke($4, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:374
+assert_trap(() => invoke($4, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:375
+assert_trap(() => invoke($4, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:376
+assert_trap(() => invoke($4, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:377
+assert_trap(() => invoke($4, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:378
+assert_trap(() => invoke($4, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:379
+assert_trap(() => invoke($4, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:380
+assert_trap(() => invoke($4, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:381
+assert_trap(() => invoke($4, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:383
+let $5 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:413
+invoke($5, `test`, []);
+
+// ./test/core/table_copy.wast:414
+assert_trap(() => invoke($5, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:415
+assert_trap(() => invoke($5, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:416
+assert_return(() => invoke($5, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:417
+assert_return(() => invoke($5, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:418
+assert_return(() => invoke($5, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:419
+assert_return(() => invoke($5, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:420
+assert_trap(() => invoke($5, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:421
+assert_trap(() => invoke($5, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:422
+assert_trap(() => invoke($5, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:423
+assert_trap(() => invoke($5, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:424
+assert_trap(() => invoke($5, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:425
+assert_trap(() => invoke($5, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:426
+assert_return(() => invoke($5, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:427
+assert_return(() => invoke($5, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:428
+assert_return(() => invoke($5, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:429
+assert_return(() => invoke($5, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:430
+assert_return(() => invoke($5, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:431
+assert_trap(() => invoke($5, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:432
+assert_trap(() => invoke($5, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:433
+assert_trap(() => invoke($5, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:434
+assert_trap(() => invoke($5, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:435
+assert_trap(() => invoke($5, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:436
+assert_trap(() => invoke($5, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:437
+assert_trap(() => invoke($5, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:438
+assert_trap(() => invoke($5, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:439
+assert_trap(() => invoke($5, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:440
+assert_trap(() => invoke($5, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:441
+assert_trap(() => invoke($5, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:442
+assert_trap(() => invoke($5, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:443
+assert_trap(() => invoke($5, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:444
+assert_trap(() => invoke($5, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:445
+assert_trap(() => invoke($5, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:446
+assert_trap(() => invoke($5, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:447
+assert_return(() => invoke($5, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:448
+assert_return(() => invoke($5, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:449
+assert_return(() => invoke($5, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:450
+assert_return(() => invoke($5, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:451
+assert_trap(() => invoke($5, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:452
+assert_trap(() => invoke($5, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:453
+assert_trap(() => invoke($5, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:454
+assert_trap(() => invoke($5, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:455
+assert_return(() => invoke($5, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:456
+assert_return(() => invoke($5, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:457
+assert_return(() => invoke($5, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:458
+assert_return(() => invoke($5, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:459
+assert_return(() => invoke($5, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:460
+assert_trap(() => invoke($5, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:461
+assert_trap(() => invoke($5, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:462
+assert_trap(() => invoke($5, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:463
+assert_trap(() => invoke($5, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:464
+assert_trap(() => invoke($5, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:465
+assert_trap(() => invoke($5, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:466
+assert_trap(() => invoke($5, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:467
+assert_trap(() => invoke($5, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:468
+assert_trap(() => invoke($5, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:469
+assert_trap(() => invoke($5, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:470
+assert_trap(() => invoke($5, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:471
+assert_trap(() => invoke($5, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:472
+assert_trap(() => invoke($5, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:473
+assert_trap(() => invoke($5, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:475
+let $6 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:505
+invoke($6, `test`, []);
+
+// ./test/core/table_copy.wast:506
+assert_trap(() => invoke($6, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:507
+assert_trap(() => invoke($6, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:508
+assert_return(() => invoke($6, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:509
+assert_return(() => invoke($6, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:510
+assert_return(() => invoke($6, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:511
+assert_return(() => invoke($6, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:512
+assert_trap(() => invoke($6, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:513
+assert_trap(() => invoke($6, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:514
+assert_trap(() => invoke($6, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:515
+assert_trap(() => invoke($6, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:516
+assert_trap(() => invoke($6, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:517
+assert_trap(() => invoke($6, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:518
+assert_return(() => invoke($6, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:519
+assert_return(() => invoke($6, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:520
+assert_return(() => invoke($6, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:521
+assert_return(() => invoke($6, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:522
+assert_return(() => invoke($6, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:523
+assert_trap(() => invoke($6, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:524
+assert_trap(() => invoke($6, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:525
+assert_trap(() => invoke($6, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:526
+assert_trap(() => invoke($6, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:527
+assert_trap(() => invoke($6, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:528
+assert_trap(() => invoke($6, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:529
+assert_trap(() => invoke($6, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:530
+assert_trap(() => invoke($6, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:531
+assert_trap(() => invoke($6, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:532
+assert_return(() => invoke($6, `check_t0`, [26]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:533
+assert_return(() => invoke($6, `check_t0`, [27]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:534
+assert_trap(() => invoke($6, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:535
+assert_trap(() => invoke($6, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:536
+assert_trap(() => invoke($6, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:537
+assert_trap(() => invoke($6, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:538
+assert_trap(() => invoke($6, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:539
+assert_return(() => invoke($6, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:540
+assert_return(() => invoke($6, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:541
+assert_return(() => invoke($6, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:542
+assert_return(() => invoke($6, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:543
+assert_trap(() => invoke($6, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:544
+assert_trap(() => invoke($6, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:545
+assert_trap(() => invoke($6, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:546
+assert_trap(() => invoke($6, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:547
+assert_return(() => invoke($6, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:548
+assert_return(() => invoke($6, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:549
+assert_return(() => invoke($6, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:550
+assert_return(() => invoke($6, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:551
+assert_return(() => invoke($6, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:552
+assert_trap(() => invoke($6, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:553
+assert_trap(() => invoke($6, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:554
+assert_trap(() => invoke($6, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:555
+assert_trap(() => invoke($6, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:556
+assert_trap(() => invoke($6, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:557
+assert_trap(() => invoke($6, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:558
+assert_trap(() => invoke($6, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:559
+assert_trap(() => invoke($6, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:560
+assert_trap(() => invoke($6, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:561
+assert_trap(() => invoke($6, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:562
+assert_trap(() => invoke($6, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:563
+assert_trap(() => invoke($6, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:564
+assert_trap(() => invoke($6, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:565
+assert_trap(() => invoke($6, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:567
+let $7 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:597
+invoke($7, `test`, []);
+
+// ./test/core/table_copy.wast:598
+assert_trap(() => invoke($7, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:599
+assert_trap(() => invoke($7, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:600
+assert_return(() => invoke($7, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:601
+assert_return(() => invoke($7, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:602
+assert_return(() => invoke($7, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:603
+assert_return(() => invoke($7, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:604
+assert_trap(() => invoke($7, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:605
+assert_trap(() => invoke($7, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:606
+assert_trap(() => invoke($7, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:607
+assert_trap(() => invoke($7, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:608
+assert_return(() => invoke($7, `check_t0`, [10]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:609
+assert_return(() => invoke($7, `check_t0`, [11]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:610
+assert_return(() => invoke($7, `check_t0`, [12]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:611
+assert_return(() => invoke($7, `check_t0`, [13]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:612
+assert_return(() => invoke($7, `check_t0`, [14]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:613
+assert_trap(() => invoke($7, `check_t0`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:614
+assert_trap(() => invoke($7, `check_t0`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:615
+assert_trap(() => invoke($7, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:616
+assert_trap(() => invoke($7, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:617
+assert_trap(() => invoke($7, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:618
+assert_trap(() => invoke($7, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:619
+assert_trap(() => invoke($7, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:620
+assert_trap(() => invoke($7, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:621
+assert_trap(() => invoke($7, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:622
+assert_trap(() => invoke($7, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:623
+assert_trap(() => invoke($7, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:624
+assert_trap(() => invoke($7, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:625
+assert_trap(() => invoke($7, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:626
+assert_trap(() => invoke($7, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:627
+assert_trap(() => invoke($7, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:628
+assert_trap(() => invoke($7, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:629
+assert_trap(() => invoke($7, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:630
+assert_trap(() => invoke($7, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:631
+assert_return(() => invoke($7, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:632
+assert_return(() => invoke($7, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:633
+assert_return(() => invoke($7, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:634
+assert_return(() => invoke($7, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:635
+assert_trap(() => invoke($7, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:636
+assert_trap(() => invoke($7, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:637
+assert_trap(() => invoke($7, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:638
+assert_trap(() => invoke($7, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:639
+assert_return(() => invoke($7, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:640
+assert_return(() => invoke($7, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:641
+assert_return(() => invoke($7, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:642
+assert_return(() => invoke($7, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:643
+assert_return(() => invoke($7, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:644
+assert_trap(() => invoke($7, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:645
+assert_trap(() => invoke($7, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:646
+assert_trap(() => invoke($7, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:647
+assert_trap(() => invoke($7, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:648
+assert_trap(() => invoke($7, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:649
+assert_trap(() => invoke($7, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:650
+assert_trap(() => invoke($7, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:651
+assert_trap(() => invoke($7, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:652
+assert_trap(() => invoke($7, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:653
+assert_trap(() => invoke($7, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:654
+assert_trap(() => invoke($7, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:655
+assert_trap(() => invoke($7, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:656
+assert_trap(() => invoke($7, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:657
+assert_trap(() => invoke($7, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:659
+let $8 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:689
+invoke($8, `test`, []);
+
+// ./test/core/table_copy.wast:690
+assert_trap(() => invoke($8, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:691
+assert_trap(() => invoke($8, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:692
+assert_return(() => invoke($8, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:693
+assert_return(() => invoke($8, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:694
+assert_return(() => invoke($8, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:695
+assert_return(() => invoke($8, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:696
+assert_trap(() => invoke($8, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:697
+assert_trap(() => invoke($8, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:698
+assert_trap(() => invoke($8, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:699
+assert_trap(() => invoke($8, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:700
+assert_trap(() => invoke($8, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:701
+assert_trap(() => invoke($8, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:702
+assert_trap(() => invoke($8, `check_t0`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:703
+assert_trap(() => invoke($8, `check_t0`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:704
+assert_return(() => invoke($8, `check_t0`, [14]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:705
+assert_return(() => invoke($8, `check_t0`, [15]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:706
+assert_return(() => invoke($8, `check_t0`, [16]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:707
+assert_return(() => invoke($8, `check_t0`, [17]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:708
+assert_return(() => invoke($8, `check_t0`, [18]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:709
+assert_trap(() => invoke($8, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:710
+assert_trap(() => invoke($8, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:711
+assert_trap(() => invoke($8, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:712
+assert_trap(() => invoke($8, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:713
+assert_trap(() => invoke($8, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:714
+assert_trap(() => invoke($8, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:715
+assert_trap(() => invoke($8, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:716
+assert_trap(() => invoke($8, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:717
+assert_trap(() => invoke($8, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:718
+assert_trap(() => invoke($8, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:719
+assert_trap(() => invoke($8, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:720
+assert_trap(() => invoke($8, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:721
+assert_trap(() => invoke($8, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:722
+assert_trap(() => invoke($8, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:723
+assert_return(() => invoke($8, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:724
+assert_return(() => invoke($8, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:725
+assert_return(() => invoke($8, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:726
+assert_return(() => invoke($8, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:727
+assert_trap(() => invoke($8, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:728
+assert_trap(() => invoke($8, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:729
+assert_trap(() => invoke($8, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:730
+assert_trap(() => invoke($8, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:731
+assert_return(() => invoke($8, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:732
+assert_return(() => invoke($8, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:733
+assert_return(() => invoke($8, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:734
+assert_return(() => invoke($8, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:735
+assert_return(() => invoke($8, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:736
+assert_trap(() => invoke($8, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:737
+assert_trap(() => invoke($8, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:738
+assert_trap(() => invoke($8, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:739
+assert_trap(() => invoke($8, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:740
+assert_trap(() => invoke($8, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:741
+assert_trap(() => invoke($8, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:742
+assert_trap(() => invoke($8, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:743
+assert_trap(() => invoke($8, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:744
+assert_trap(() => invoke($8, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:745
+assert_trap(() => invoke($8, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:746
+assert_trap(() => invoke($8, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:747
+assert_trap(() => invoke($8, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:748
+assert_trap(() => invoke($8, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:749
+assert_trap(() => invoke($8, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:751
+let $9 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 10) (i32.const 0) (i32.const 20)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:781
+invoke($9, `test`, []);
+
+// ./test/core/table_copy.wast:782
+assert_trap(() => invoke($9, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:783
+assert_trap(() => invoke($9, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:784
+assert_return(() => invoke($9, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:785
+assert_return(() => invoke($9, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:786
+assert_return(() => invoke($9, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:787
+assert_return(() => invoke($9, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:788
+assert_trap(() => invoke($9, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:789
+assert_trap(() => invoke($9, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:790
+assert_trap(() => invoke($9, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:791
+assert_trap(() => invoke($9, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:792
+assert_trap(() => invoke($9, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:793
+assert_trap(() => invoke($9, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:794
+assert_return(() => invoke($9, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:795
+assert_return(() => invoke($9, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:796
+assert_return(() => invoke($9, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:797
+assert_return(() => invoke($9, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:798
+assert_return(() => invoke($9, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:799
+assert_trap(() => invoke($9, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:800
+assert_trap(() => invoke($9, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:801
+assert_trap(() => invoke($9, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:802
+assert_trap(() => invoke($9, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:803
+assert_trap(() => invoke($9, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:804
+assert_trap(() => invoke($9, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:805
+assert_trap(() => invoke($9, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:806
+assert_trap(() => invoke($9, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:807
+assert_trap(() => invoke($9, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:808
+assert_trap(() => invoke($9, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:809
+assert_trap(() => invoke($9, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:810
+assert_trap(() => invoke($9, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:811
+assert_trap(() => invoke($9, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:812
+assert_trap(() => invoke($9, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:813
+assert_trap(() => invoke($9, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:814
+assert_trap(() => invoke($9, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:815
+assert_return(() => invoke($9, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:816
+assert_return(() => invoke($9, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:817
+assert_return(() => invoke($9, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:818
+assert_return(() => invoke($9, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:819
+assert_trap(() => invoke($9, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:820
+assert_trap(() => invoke($9, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:821
+assert_trap(() => invoke($9, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:822
+assert_trap(() => invoke($9, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:823
+assert_trap(() => invoke($9, `check_t1`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:824
+assert_return(() => invoke($9, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:825
+assert_return(() => invoke($9, `check_t1`, [13]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:826
+assert_return(() => invoke($9, `check_t1`, [14]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:827
+assert_return(() => invoke($9, `check_t1`, [15]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:828
+assert_trap(() => invoke($9, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:829
+assert_trap(() => invoke($9, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:830
+assert_trap(() => invoke($9, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:831
+assert_trap(() => invoke($9, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:832
+assert_trap(() => invoke($9, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:833
+assert_trap(() => invoke($9, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:834
+assert_return(() => invoke($9, `check_t1`, [22]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:835
+assert_return(() => invoke($9, `check_t1`, [23]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:836
+assert_return(() => invoke($9, `check_t1`, [24]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:837
+assert_return(() => invoke($9, `check_t1`, [25]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:838
+assert_return(() => invoke($9, `check_t1`, [26]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:839
+assert_trap(() => invoke($9, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:840
+assert_trap(() => invoke($9, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:841
+assert_trap(() => invoke($9, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:843
+let $10 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:873
+invoke($10, `test`, []);
+
+// ./test/core/table_copy.wast:874
+assert_trap(() => invoke($10, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:875
+assert_trap(() => invoke($10, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:876
+assert_return(() => invoke($10, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:877
+assert_return(() => invoke($10, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:878
+assert_return(() => invoke($10, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:879
+assert_return(() => invoke($10, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:880
+assert_trap(() => invoke($10, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:881
+assert_trap(() => invoke($10, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:882
+assert_trap(() => invoke($10, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:883
+assert_trap(() => invoke($10, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:884
+assert_trap(() => invoke($10, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:885
+assert_trap(() => invoke($10, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:886
+assert_return(() => invoke($10, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:887
+assert_return(() => invoke($10, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:888
+assert_return(() => invoke($10, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:889
+assert_return(() => invoke($10, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:890
+assert_return(() => invoke($10, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:891
+assert_trap(() => invoke($10, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:892
+assert_trap(() => invoke($10, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:893
+assert_trap(() => invoke($10, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:894
+assert_trap(() => invoke($10, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:895
+assert_trap(() => invoke($10, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:896
+assert_trap(() => invoke($10, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:897
+assert_trap(() => invoke($10, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:898
+assert_trap(() => invoke($10, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:899
+assert_trap(() => invoke($10, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:900
+assert_trap(() => invoke($10, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:901
+assert_trap(() => invoke($10, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:902
+assert_trap(() => invoke($10, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:903
+assert_trap(() => invoke($10, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:904
+assert_trap(() => invoke($10, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:905
+assert_trap(() => invoke($10, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:906
+assert_trap(() => invoke($10, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:907
+assert_return(() => invoke($10, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:908
+assert_return(() => invoke($10, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:909
+assert_return(() => invoke($10, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:910
+assert_return(() => invoke($10, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:911
+assert_trap(() => invoke($10, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:912
+assert_trap(() => invoke($10, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:913
+assert_trap(() => invoke($10, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:914
+assert_trap(() => invoke($10, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:915
+assert_return(() => invoke($10, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:916
+assert_return(() => invoke($10, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:917
+assert_return(() => invoke($10, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:918
+assert_return(() => invoke($10, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:919
+assert_return(() => invoke($10, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:920
+assert_trap(() => invoke($10, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:921
+assert_trap(() => invoke($10, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:922
+assert_trap(() => invoke($10, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:923
+assert_trap(() => invoke($10, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:924
+assert_trap(() => invoke($10, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:925
+assert_trap(() => invoke($10, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:926
+assert_trap(() => invoke($10, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:927
+assert_trap(() => invoke($10, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:928
+assert_trap(() => invoke($10, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:929
+assert_trap(() => invoke($10, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:930
+assert_trap(() => invoke($10, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:931
+assert_trap(() => invoke($10, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:932
+assert_trap(() => invoke($10, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:933
+assert_trap(() => invoke($10, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:935
+let $11 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:965
+invoke($11, `test`, []);
+
+// ./test/core/table_copy.wast:966
+assert_trap(() => invoke($11, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:967
+assert_trap(() => invoke($11, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:968
+assert_return(() => invoke($11, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:969
+assert_return(() => invoke($11, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:970
+assert_return(() => invoke($11, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:971
+assert_return(() => invoke($11, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:972
+assert_trap(() => invoke($11, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:973
+assert_trap(() => invoke($11, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:974
+assert_trap(() => invoke($11, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:975
+assert_trap(() => invoke($11, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:976
+assert_trap(() => invoke($11, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:977
+assert_trap(() => invoke($11, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:978
+assert_return(() => invoke($11, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:979
+assert_return(() => invoke($11, `check_t0`, [13]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:980
+assert_return(() => invoke($11, `check_t0`, [14]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:981
+assert_return(() => invoke($11, `check_t0`, [15]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:982
+assert_return(() => invoke($11, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:983
+assert_trap(() => invoke($11, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:984
+assert_trap(() => invoke($11, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:985
+assert_trap(() => invoke($11, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:986
+assert_trap(() => invoke($11, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:987
+assert_trap(() => invoke($11, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:988
+assert_trap(() => invoke($11, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:989
+assert_trap(() => invoke($11, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:990
+assert_trap(() => invoke($11, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:991
+assert_trap(() => invoke($11, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:992
+assert_trap(() => invoke($11, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:993
+assert_trap(() => invoke($11, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:994
+assert_trap(() => invoke($11, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:995
+assert_trap(() => invoke($11, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:996
+assert_trap(() => invoke($11, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:997
+assert_trap(() => invoke($11, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:998
+assert_trap(() => invoke($11, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:999
+assert_return(() => invoke($11, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1000
+assert_return(() => invoke($11, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1001
+assert_return(() => invoke($11, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1002
+assert_return(() => invoke($11, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1003
+assert_trap(() => invoke($11, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1004
+assert_trap(() => invoke($11, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1005
+assert_trap(() => invoke($11, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1006
+assert_trap(() => invoke($11, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1007
+assert_return(() => invoke($11, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1008
+assert_return(() => invoke($11, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1009
+assert_return(() => invoke($11, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1010
+assert_return(() => invoke($11, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1011
+assert_return(() => invoke($11, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1012
+assert_trap(() => invoke($11, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1013
+assert_trap(() => invoke($11, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1014
+assert_trap(() => invoke($11, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1015
+assert_trap(() => invoke($11, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1016
+assert_trap(() => invoke($11, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1017
+assert_trap(() => invoke($11, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1018
+assert_trap(() => invoke($11, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1019
+assert_trap(() => invoke($11, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1020
+assert_trap(() => invoke($11, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1021
+assert_trap(() => invoke($11, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1022
+assert_trap(() => invoke($11, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1023
+assert_trap(() => invoke($11, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1024
+assert_trap(() => invoke($11, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1025
+assert_trap(() => invoke($11, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1027
+let $12 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1057
+invoke($12, `test`, []);
+
+// ./test/core/table_copy.wast:1058
+assert_trap(() => invoke($12, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1059
+assert_trap(() => invoke($12, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1060
+assert_return(() => invoke($12, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1061
+assert_return(() => invoke($12, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1062
+assert_return(() => invoke($12, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1063
+assert_return(() => invoke($12, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1064
+assert_trap(() => invoke($12, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1065
+assert_trap(() => invoke($12, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1066
+assert_trap(() => invoke($12, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1067
+assert_trap(() => invoke($12, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1068
+assert_trap(() => invoke($12, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1069
+assert_trap(() => invoke($12, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1070
+assert_return(() => invoke($12, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1071
+assert_return(() => invoke($12, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1072
+assert_return(() => invoke($12, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1073
+assert_return(() => invoke($12, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1074
+assert_return(() => invoke($12, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1075
+assert_trap(() => invoke($12, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1076
+assert_trap(() => invoke($12, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1077
+assert_trap(() => invoke($12, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1078
+assert_trap(() => invoke($12, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1079
+assert_trap(() => invoke($12, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1080
+assert_trap(() => invoke($12, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1081
+assert_trap(() => invoke($12, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1082
+assert_trap(() => invoke($12, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1083
+assert_return(() => invoke($12, `check_t0`, [25]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1084
+assert_return(() => invoke($12, `check_t0`, [26]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1085
+assert_trap(() => invoke($12, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1086
+assert_trap(() => invoke($12, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1087
+assert_trap(() => invoke($12, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1088
+assert_trap(() => invoke($12, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1089
+assert_trap(() => invoke($12, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1090
+assert_trap(() => invoke($12, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1091
+assert_return(() => invoke($12, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1092
+assert_return(() => invoke($12, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1093
+assert_return(() => invoke($12, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1094
+assert_return(() => invoke($12, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1095
+assert_trap(() => invoke($12, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1096
+assert_trap(() => invoke($12, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1097
+assert_trap(() => invoke($12, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1098
+assert_trap(() => invoke($12, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1099
+assert_return(() => invoke($12, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1100
+assert_return(() => invoke($12, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1101
+assert_return(() => invoke($12, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1102
+assert_return(() => invoke($12, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1103
+assert_return(() => invoke($12, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1104
+assert_trap(() => invoke($12, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1105
+assert_trap(() => invoke($12, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1106
+assert_trap(() => invoke($12, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1107
+assert_trap(() => invoke($12, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1108
+assert_trap(() => invoke($12, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1109
+assert_trap(() => invoke($12, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1110
+assert_trap(() => invoke($12, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1111
+assert_trap(() => invoke($12, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1112
+assert_trap(() => invoke($12, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1113
+assert_trap(() => invoke($12, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1114
+assert_trap(() => invoke($12, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1115
+assert_trap(() => invoke($12, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1116
+assert_trap(() => invoke($12, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1117
+assert_trap(() => invoke($12, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1119
+let $13 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1149
+invoke($13, `test`, []);
+
+// ./test/core/table_copy.wast:1150
+assert_trap(() => invoke($13, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1151
+assert_trap(() => invoke($13, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1152
+assert_return(() => invoke($13, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1153
+assert_return(() => invoke($13, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1154
+assert_return(() => invoke($13, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1155
+assert_return(() => invoke($13, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1156
+assert_trap(() => invoke($13, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1157
+assert_trap(() => invoke($13, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1158
+assert_trap(() => invoke($13, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1159
+assert_trap(() => invoke($13, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1160
+assert_trap(() => invoke($13, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1161
+assert_trap(() => invoke($13, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1162
+assert_return(() => invoke($13, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1163
+assert_trap(() => invoke($13, `check_t0`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1164
+assert_trap(() => invoke($13, `check_t0`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1165
+assert_trap(() => invoke($13, `check_t0`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1166
+assert_return(() => invoke($13, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1167
+assert_trap(() => invoke($13, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1168
+assert_trap(() => invoke($13, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1169
+assert_trap(() => invoke($13, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1170
+assert_trap(() => invoke($13, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1171
+assert_trap(() => invoke($13, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1172
+assert_trap(() => invoke($13, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1173
+assert_trap(() => invoke($13, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1174
+assert_trap(() => invoke($13, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1175
+assert_trap(() => invoke($13, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1176
+assert_trap(() => invoke($13, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1177
+assert_trap(() => invoke($13, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1178
+assert_trap(() => invoke($13, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1179
+assert_trap(() => invoke($13, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1180
+assert_trap(() => invoke($13, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1181
+assert_trap(() => invoke($13, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1182
+assert_trap(() => invoke($13, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1183
+assert_return(() => invoke($13, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1184
+assert_return(() => invoke($13, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1185
+assert_return(() => invoke($13, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1186
+assert_return(() => invoke($13, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1187
+assert_trap(() => invoke($13, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1188
+assert_trap(() => invoke($13, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1189
+assert_trap(() => invoke($13, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1190
+assert_trap(() => invoke($13, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1191
+assert_return(() => invoke($13, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1192
+assert_return(() => invoke($13, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1193
+assert_return(() => invoke($13, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1194
+assert_return(() => invoke($13, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1195
+assert_return(() => invoke($13, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1196
+assert_trap(() => invoke($13, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1197
+assert_trap(() => invoke($13, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1198
+assert_trap(() => invoke($13, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1199
+assert_trap(() => invoke($13, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1200
+assert_trap(() => invoke($13, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1201
+assert_trap(() => invoke($13, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1202
+assert_trap(() => invoke($13, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1203
+assert_trap(() => invoke($13, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1204
+assert_trap(() => invoke($13, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1205
+assert_trap(() => invoke($13, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1206
+assert_trap(() => invoke($13, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1207
+assert_trap(() => invoke($13, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1208
+assert_trap(() => invoke($13, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1209
+assert_trap(() => invoke($13, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1211
+let $14 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1241
+invoke($14, `test`, []);
+
+// ./test/core/table_copy.wast:1242
+assert_trap(() => invoke($14, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1243
+assert_trap(() => invoke($14, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1244
+assert_return(() => invoke($14, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1245
+assert_return(() => invoke($14, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1246
+assert_return(() => invoke($14, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1247
+assert_return(() => invoke($14, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1248
+assert_trap(() => invoke($14, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1249
+assert_trap(() => invoke($14, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1250
+assert_trap(() => invoke($14, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1251
+assert_trap(() => invoke($14, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1252
+assert_trap(() => invoke($14, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1253
+assert_trap(() => invoke($14, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1254
+assert_return(() => invoke($14, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1255
+assert_return(() => invoke($14, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1256
+assert_return(() => invoke($14, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1257
+assert_return(() => invoke($14, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1258
+assert_return(() => invoke($14, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1259
+assert_trap(() => invoke($14, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1260
+assert_trap(() => invoke($14, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1261
+assert_trap(() => invoke($14, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1262
+assert_trap(() => invoke($14, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1263
+assert_trap(() => invoke($14, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1264
+assert_trap(() => invoke($14, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1265
+assert_trap(() => invoke($14, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1266
+assert_trap(() => invoke($14, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1267
+assert_trap(() => invoke($14, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1268
+assert_trap(() => invoke($14, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1269
+assert_trap(() => invoke($14, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1270
+assert_trap(() => invoke($14, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1271
+assert_trap(() => invoke($14, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1272
+assert_trap(() => invoke($14, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1273
+assert_trap(() => invoke($14, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1274
+assert_trap(() => invoke($14, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1275
+assert_return(() => invoke($14, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1276
+assert_return(() => invoke($14, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1277
+assert_return(() => invoke($14, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1278
+assert_return(() => invoke($14, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1279
+assert_trap(() => invoke($14, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1280
+assert_trap(() => invoke($14, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1281
+assert_trap(() => invoke($14, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1282
+assert_trap(() => invoke($14, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1283
+assert_return(() => invoke($14, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1284
+assert_return(() => invoke($14, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1285
+assert_return(() => invoke($14, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1286
+assert_return(() => invoke($14, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1287
+assert_return(() => invoke($14, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1288
+assert_trap(() => invoke($14, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1289
+assert_trap(() => invoke($14, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1290
+assert_trap(() => invoke($14, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1291
+assert_trap(() => invoke($14, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1292
+assert_trap(() => invoke($14, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1293
+assert_trap(() => invoke($14, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1294
+assert_trap(() => invoke($14, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1295
+assert_trap(() => invoke($14, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1296
+assert_trap(() => invoke($14, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1297
+assert_trap(() => invoke($14, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1298
+assert_trap(() => invoke($14, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1299
+assert_trap(() => invoke($14, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1300
+assert_trap(() => invoke($14, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1301
+assert_trap(() => invoke($14, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1303
+let $15 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1333
+invoke($15, `test`, []);
+
+// ./test/core/table_copy.wast:1334
+assert_trap(() => invoke($15, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1335
+assert_trap(() => invoke($15, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1336
+assert_return(() => invoke($15, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1337
+assert_return(() => invoke($15, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1338
+assert_return(() => invoke($15, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1339
+assert_return(() => invoke($15, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1340
+assert_trap(() => invoke($15, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1341
+assert_trap(() => invoke($15, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1342
+assert_trap(() => invoke($15, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1343
+assert_trap(() => invoke($15, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1344
+assert_trap(() => invoke($15, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1345
+assert_trap(() => invoke($15, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1346
+assert_return(() => invoke($15, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1347
+assert_return(() => invoke($15, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1348
+assert_return(() => invoke($15, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1349
+assert_return(() => invoke($15, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1350
+assert_return(() => invoke($15, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1351
+assert_trap(() => invoke($15, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1352
+assert_trap(() => invoke($15, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1353
+assert_trap(() => invoke($15, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1354
+assert_trap(() => invoke($15, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1355
+assert_trap(() => invoke($15, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1356
+assert_trap(() => invoke($15, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1357
+assert_trap(() => invoke($15, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1358
+assert_trap(() => invoke($15, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1359
+assert_trap(() => invoke($15, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1360
+assert_return(() => invoke($15, `check_t0`, [26]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1361
+assert_return(() => invoke($15, `check_t0`, [27]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1362
+assert_trap(() => invoke($15, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1363
+assert_trap(() => invoke($15, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1364
+assert_trap(() => invoke($15, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1365
+assert_trap(() => invoke($15, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1366
+assert_trap(() => invoke($15, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1367
+assert_return(() => invoke($15, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1368
+assert_return(() => invoke($15, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1369
+assert_return(() => invoke($15, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1370
+assert_return(() => invoke($15, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1371
+assert_trap(() => invoke($15, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1372
+assert_trap(() => invoke($15, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1373
+assert_trap(() => invoke($15, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1374
+assert_trap(() => invoke($15, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1375
+assert_return(() => invoke($15, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1376
+assert_return(() => invoke($15, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1377
+assert_return(() => invoke($15, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1378
+assert_return(() => invoke($15, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1379
+assert_return(() => invoke($15, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1380
+assert_trap(() => invoke($15, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1381
+assert_trap(() => invoke($15, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1382
+assert_trap(() => invoke($15, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1383
+assert_trap(() => invoke($15, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1384
+assert_trap(() => invoke($15, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1385
+assert_trap(() => invoke($15, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1386
+assert_trap(() => invoke($15, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1387
+assert_trap(() => invoke($15, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1388
+assert_trap(() => invoke($15, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1389
+assert_trap(() => invoke($15, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1390
+assert_trap(() => invoke($15, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1391
+assert_trap(() => invoke($15, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1392
+assert_trap(() => invoke($15, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1393
+assert_trap(() => invoke($15, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1395
+let $16 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1425
+invoke($16, `test`, []);
+
+// ./test/core/table_copy.wast:1426
+assert_trap(() => invoke($16, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1427
+assert_trap(() => invoke($16, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1428
+assert_return(() => invoke($16, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1429
+assert_return(() => invoke($16, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1430
+assert_return(() => invoke($16, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1431
+assert_return(() => invoke($16, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1432
+assert_trap(() => invoke($16, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1433
+assert_trap(() => invoke($16, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1434
+assert_trap(() => invoke($16, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1435
+assert_trap(() => invoke($16, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1436
+assert_return(() => invoke($16, `check_t0`, [10]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1437
+assert_return(() => invoke($16, `check_t0`, [11]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1438
+assert_return(() => invoke($16, `check_t0`, [12]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1439
+assert_return(() => invoke($16, `check_t0`, [13]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1440
+assert_return(() => invoke($16, `check_t0`, [14]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1441
+assert_trap(() => invoke($16, `check_t0`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1442
+assert_trap(() => invoke($16, `check_t0`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1443
+assert_trap(() => invoke($16, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1444
+assert_trap(() => invoke($16, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1445
+assert_trap(() => invoke($16, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1446
+assert_trap(() => invoke($16, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1447
+assert_trap(() => invoke($16, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1448
+assert_trap(() => invoke($16, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1449
+assert_trap(() => invoke($16, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1450
+assert_trap(() => invoke($16, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1451
+assert_trap(() => invoke($16, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1452
+assert_trap(() => invoke($16, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1453
+assert_trap(() => invoke($16, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1454
+assert_trap(() => invoke($16, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1455
+assert_trap(() => invoke($16, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1456
+assert_trap(() => invoke($16, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1457
+assert_trap(() => invoke($16, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1458
+assert_trap(() => invoke($16, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1459
+assert_return(() => invoke($16, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1460
+assert_return(() => invoke($16, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1461
+assert_return(() => invoke($16, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1462
+assert_return(() => invoke($16, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1463
+assert_trap(() => invoke($16, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1464
+assert_trap(() => invoke($16, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1465
+assert_trap(() => invoke($16, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1466
+assert_trap(() => invoke($16, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1467
+assert_return(() => invoke($16, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1468
+assert_return(() => invoke($16, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1469
+assert_return(() => invoke($16, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1470
+assert_return(() => invoke($16, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1471
+assert_return(() => invoke($16, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1472
+assert_trap(() => invoke($16, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1473
+assert_trap(() => invoke($16, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1474
+assert_trap(() => invoke($16, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1475
+assert_trap(() => invoke($16, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1476
+assert_trap(() => invoke($16, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1477
+assert_trap(() => invoke($16, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1478
+assert_trap(() => invoke($16, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1479
+assert_trap(() => invoke($16, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1480
+assert_trap(() => invoke($16, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1481
+assert_trap(() => invoke($16, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1482
+assert_trap(() => invoke($16, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1483
+assert_trap(() => invoke($16, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1484
+assert_trap(() => invoke($16, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1485
+assert_trap(() => invoke($16, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1487
+let $17 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t1 $$t1 (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1517
+invoke($17, `test`, []);
+
+// ./test/core/table_copy.wast:1518
+assert_trap(() => invoke($17, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1519
+assert_trap(() => invoke($17, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1520
+assert_return(() => invoke($17, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1521
+assert_return(() => invoke($17, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1522
+assert_return(() => invoke($17, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1523
+assert_return(() => invoke($17, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1524
+assert_trap(() => invoke($17, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1525
+assert_trap(() => invoke($17, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1526
+assert_trap(() => invoke($17, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1527
+assert_trap(() => invoke($17, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1528
+assert_trap(() => invoke($17, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1529
+assert_trap(() => invoke($17, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1530
+assert_trap(() => invoke($17, `check_t0`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1531
+assert_trap(() => invoke($17, `check_t0`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1532
+assert_return(() => invoke($17, `check_t0`, [14]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1533
+assert_return(() => invoke($17, `check_t0`, [15]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1534
+assert_return(() => invoke($17, `check_t0`, [16]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1535
+assert_return(() => invoke($17, `check_t0`, [17]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1536
+assert_return(() => invoke($17, `check_t0`, [18]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1537
+assert_trap(() => invoke($17, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1538
+assert_trap(() => invoke($17, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1539
+assert_trap(() => invoke($17, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1540
+assert_trap(() => invoke($17, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1541
+assert_trap(() => invoke($17, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1542
+assert_trap(() => invoke($17, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1543
+assert_trap(() => invoke($17, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1544
+assert_trap(() => invoke($17, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1545
+assert_trap(() => invoke($17, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1546
+assert_trap(() => invoke($17, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1547
+assert_trap(() => invoke($17, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1548
+assert_trap(() => invoke($17, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1549
+assert_trap(() => invoke($17, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1550
+assert_trap(() => invoke($17, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1551
+assert_return(() => invoke($17, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1552
+assert_return(() => invoke($17, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1553
+assert_return(() => invoke($17, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1554
+assert_return(() => invoke($17, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1555
+assert_trap(() => invoke($17, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1556
+assert_trap(() => invoke($17, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1557
+assert_trap(() => invoke($17, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1558
+assert_trap(() => invoke($17, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1559
+assert_return(() => invoke($17, `check_t1`, [11]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1560
+assert_return(() => invoke($17, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1561
+assert_return(() => invoke($17, `check_t1`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1562
+assert_return(() => invoke($17, `check_t1`, [14]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1563
+assert_return(() => invoke($17, `check_t1`, [15]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1564
+assert_trap(() => invoke($17, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1565
+assert_trap(() => invoke($17, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1566
+assert_trap(() => invoke($17, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1567
+assert_trap(() => invoke($17, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1568
+assert_trap(() => invoke($17, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1569
+assert_trap(() => invoke($17, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1570
+assert_trap(() => invoke($17, `check_t1`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1571
+assert_trap(() => invoke($17, `check_t1`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1572
+assert_trap(() => invoke($17, `check_t1`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1573
+assert_trap(() => invoke($17, `check_t1`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1574
+assert_trap(() => invoke($17, `check_t1`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1575
+assert_trap(() => invoke($17, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1576
+assert_trap(() => invoke($17, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1577
+assert_trap(() => invoke($17, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1579
+let $18 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $$t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $$t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $$t0 $$t1 (i32.const 10) (i32.const 0) (i32.const 20)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_copy.wast:1609
+invoke($18, `test`, []);
+
+// ./test/core/table_copy.wast:1610
+assert_trap(() => invoke($18, `check_t0`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1611
+assert_trap(() => invoke($18, `check_t0`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1612
+assert_return(() => invoke($18, `check_t0`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1613
+assert_return(() => invoke($18, `check_t0`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1614
+assert_return(() => invoke($18, `check_t0`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1615
+assert_return(() => invoke($18, `check_t0`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1616
+assert_trap(() => invoke($18, `check_t0`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1617
+assert_trap(() => invoke($18, `check_t0`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1618
+assert_trap(() => invoke($18, `check_t0`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1619
+assert_trap(() => invoke($18, `check_t0`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1620
+assert_trap(() => invoke($18, `check_t0`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1621
+assert_trap(() => invoke($18, `check_t0`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1622
+assert_return(() => invoke($18, `check_t0`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1623
+assert_return(() => invoke($18, `check_t0`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1624
+assert_return(() => invoke($18, `check_t0`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1625
+assert_return(() => invoke($18, `check_t0`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1626
+assert_return(() => invoke($18, `check_t0`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1627
+assert_trap(() => invoke($18, `check_t0`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1628
+assert_trap(() => invoke($18, `check_t0`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1629
+assert_trap(() => invoke($18, `check_t0`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1630
+assert_trap(() => invoke($18, `check_t0`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1631
+assert_trap(() => invoke($18, `check_t0`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1632
+assert_trap(() => invoke($18, `check_t0`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1633
+assert_trap(() => invoke($18, `check_t0`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1634
+assert_trap(() => invoke($18, `check_t0`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1635
+assert_trap(() => invoke($18, `check_t0`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1636
+assert_trap(() => invoke($18, `check_t0`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1637
+assert_trap(() => invoke($18, `check_t0`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1638
+assert_trap(() => invoke($18, `check_t0`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1639
+assert_trap(() => invoke($18, `check_t0`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1640
+assert_trap(() => invoke($18, `check_t1`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1641
+assert_trap(() => invoke($18, `check_t1`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1642
+assert_trap(() => invoke($18, `check_t1`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1643
+assert_return(() => invoke($18, `check_t1`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1644
+assert_return(() => invoke($18, `check_t1`, [4]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1645
+assert_return(() => invoke($18, `check_t1`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1646
+assert_return(() => invoke($18, `check_t1`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1647
+assert_trap(() => invoke($18, `check_t1`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1648
+assert_trap(() => invoke($18, `check_t1`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1649
+assert_trap(() => invoke($18, `check_t1`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1650
+assert_trap(() => invoke($18, `check_t1`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1651
+assert_trap(() => invoke($18, `check_t1`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1652
+assert_return(() => invoke($18, `check_t1`, [12]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1653
+assert_return(() => invoke($18, `check_t1`, [13]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1654
+assert_return(() => invoke($18, `check_t1`, [14]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:1655
+assert_return(() => invoke($18, `check_t1`, [15]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:1656
+assert_trap(() => invoke($18, `check_t1`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1657
+assert_trap(() => invoke($18, `check_t1`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1658
+assert_trap(() => invoke($18, `check_t1`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1659
+assert_trap(() => invoke($18, `check_t1`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1660
+assert_trap(() => invoke($18, `check_t1`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1661
+assert_trap(() => invoke($18, `check_t1`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1662
+assert_return(() => invoke($18, `check_t1`, [22]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:1663
+assert_return(() => invoke($18, `check_t1`, [23]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:1664
+assert_return(() => invoke($18, `check_t1`, [24]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:1665
+assert_return(() => invoke($18, `check_t1`, [25]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:1666
+assert_return(() => invoke($18, `check_t1`, [26]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:1667
+assert_trap(() => invoke($18, `check_t1`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1668
+assert_trap(() => invoke($18, `check_t1`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1669
+assert_trap(() => invoke($18, `check_t1`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:1671
+let $19 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))`);
+
+// ./test/core/table_copy.wast:1694
+assert_trap(() => invoke($19, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1696
+let $20 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))`);
+
+// ./test/core/table_copy.wast:1719
+assert_trap(() => invoke($20, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1721
+let $21 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 15) (i32.const 25) (i32.const 6))
+    ))`);
+
+// ./test/core/table_copy.wast:1744
+assert_trap(() => invoke($21, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1746
+let $22 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))`);
+
+// ./test/core/table_copy.wast:1769
+assert_trap(() => invoke($22, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1771
+let $23 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 15) (i32.const 25) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1794
+invoke($23, `test`, []);
+
+// ./test/core/table_copy.wast:1796
+let $24 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 30) (i32.const 15) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1819
+invoke($24, `test`, []);
+
+// ./test/core/table_copy.wast:1821
+let $25 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 31) (i32.const 15) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1844
+assert_trap(() => invoke($25, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1846
+let $26 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 15) (i32.const 30) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1869
+invoke($26, `test`, []);
+
+// ./test/core/table_copy.wast:1871
+let $27 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 15) (i32.const 31) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1894
+assert_trap(() => invoke($27, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1896
+let $28 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 30) (i32.const 30) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1919
+invoke($28, `test`, []);
+
+// ./test/core/table_copy.wast:1921
+let $29 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t0 $$t0 (i32.const 31) (i32.const 31) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:1944
+assert_trap(() => invoke($29, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1946
+let $30 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))`);
+
+// ./test/core/table_copy.wast:1969
+assert_trap(() => invoke($30, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1971
+let $31 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))`);
+
+// ./test/core/table_copy.wast:1994
+assert_trap(() => invoke($31, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:1996
+let $32 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 15) (i32.const 25) (i32.const 6))
+    ))`);
+
+// ./test/core/table_copy.wast:2019
+assert_trap(() => invoke($32, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2021
+let $33 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))`);
+
+// ./test/core/table_copy.wast:2044
+assert_trap(() => invoke($33, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2046
+let $34 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 15) (i32.const 25) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2069
+invoke($34, `test`, []);
+
+// ./test/core/table_copy.wast:2071
+let $35 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 30) (i32.const 15) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2094
+invoke($35, `test`, []);
+
+// ./test/core/table_copy.wast:2096
+let $36 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 31) (i32.const 15) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2119
+assert_trap(() => invoke($36, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2121
+let $37 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 15) (i32.const 30) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2144
+invoke($37, `test`, []);
+
+// ./test/core/table_copy.wast:2146
+let $38 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 15) (i32.const 31) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2169
+assert_trap(() => invoke($38, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2171
+let $39 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 30) (i32.const 30) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2194
+invoke($39, `test`, []);
+
+// ./test/core/table_copy.wast:2196
+let $40 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $$t1 $$t0 (i32.const 31) (i32.const 31) (i32.const 0))
+    ))`);
+
+// ./test/core/table_copy.wast:2219
+assert_trap(() => invoke($40, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2221
+let $41 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2247
+assert_trap(() => invoke($41, `run`, [24, 0, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2249
+assert_return(() => invoke($41, `test`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2250
+assert_return(() => invoke($41, `test`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2251
+assert_return(() => invoke($41, `test`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2252
+assert_return(() => invoke($41, `test`, [3]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2253
+assert_return(() => invoke($41, `test`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2254
+assert_return(() => invoke($41, `test`, [5]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2255
+assert_return(() => invoke($41, `test`, [6]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2256
+assert_return(() => invoke($41, `test`, [7]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2257
+assert_trap(() => invoke($41, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2258
+assert_trap(() => invoke($41, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2259
+assert_trap(() => invoke($41, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2260
+assert_trap(() => invoke($41, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2261
+assert_trap(() => invoke($41, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2262
+assert_trap(() => invoke($41, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2263
+assert_trap(() => invoke($41, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2264
+assert_trap(() => invoke($41, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2265
+assert_trap(() => invoke($41, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2266
+assert_trap(() => invoke($41, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2267
+assert_trap(() => invoke($41, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2268
+assert_trap(() => invoke($41, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2269
+assert_trap(() => invoke($41, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2270
+assert_trap(() => invoke($41, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2271
+assert_trap(() => invoke($41, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2272
+assert_trap(() => invoke($41, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2273
+assert_trap(() => invoke($41, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2274
+assert_trap(() => invoke($41, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2275
+assert_trap(() => invoke($41, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2276
+assert_trap(() => invoke($41, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2277
+assert_trap(() => invoke($41, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2278
+assert_trap(() => invoke($41, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2279
+assert_trap(() => invoke($41, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2280
+assert_trap(() => invoke($41, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2282
+let $42 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7 $$f8)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2308
+assert_trap(() => invoke($42, `run`, [23, 0, 15]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2310
+assert_return(() => invoke($42, `test`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2311
+assert_return(() => invoke($42, `test`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2312
+assert_return(() => invoke($42, `test`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2313
+assert_return(() => invoke($42, `test`, [3]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2314
+assert_return(() => invoke($42, `test`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2315
+assert_return(() => invoke($42, `test`, [5]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2316
+assert_return(() => invoke($42, `test`, [6]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2317
+assert_return(() => invoke($42, `test`, [7]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2318
+assert_return(() => invoke($42, `test`, [8]), [value("i32", 8)]);
+
+// ./test/core/table_copy.wast:2319
+assert_trap(() => invoke($42, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2320
+assert_trap(() => invoke($42, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2321
+assert_trap(() => invoke($42, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2322
+assert_trap(() => invoke($42, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2323
+assert_trap(() => invoke($42, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2324
+assert_trap(() => invoke($42, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2325
+assert_trap(() => invoke($42, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2326
+assert_trap(() => invoke($42, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2327
+assert_trap(() => invoke($42, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2328
+assert_trap(() => invoke($42, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2329
+assert_trap(() => invoke($42, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2330
+assert_trap(() => invoke($42, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2331
+assert_trap(() => invoke($42, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2332
+assert_trap(() => invoke($42, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2333
+assert_trap(() => invoke($42, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2334
+assert_trap(() => invoke($42, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2335
+assert_trap(() => invoke($42, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2336
+assert_trap(() => invoke($42, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2337
+assert_trap(() => invoke($42, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2338
+assert_trap(() => invoke($42, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2339
+assert_trap(() => invoke($42, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2340
+assert_trap(() => invoke($42, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2341
+assert_trap(() => invoke($42, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2343
+let $43 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2369
+assert_trap(() => invoke($43, `run`, [0, 24, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2371
+assert_trap(() => invoke($43, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2372
+assert_trap(() => invoke($43, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2373
+assert_trap(() => invoke($43, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2374
+assert_trap(() => invoke($43, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2375
+assert_trap(() => invoke($43, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2376
+assert_trap(() => invoke($43, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2377
+assert_trap(() => invoke($43, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2378
+assert_trap(() => invoke($43, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2379
+assert_trap(() => invoke($43, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2380
+assert_trap(() => invoke($43, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2381
+assert_trap(() => invoke($43, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2382
+assert_trap(() => invoke($43, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2383
+assert_trap(() => invoke($43, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2384
+assert_trap(() => invoke($43, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2385
+assert_trap(() => invoke($43, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2386
+assert_trap(() => invoke($43, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2387
+assert_trap(() => invoke($43, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2388
+assert_trap(() => invoke($43, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2389
+assert_trap(() => invoke($43, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2390
+assert_trap(() => invoke($43, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2391
+assert_trap(() => invoke($43, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2392
+assert_trap(() => invoke($43, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2393
+assert_trap(() => invoke($43, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2394
+assert_trap(() => invoke($43, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2395
+assert_return(() => invoke($43, `test`, [24]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2396
+assert_return(() => invoke($43, `test`, [25]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2397
+assert_return(() => invoke($43, `test`, [26]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2398
+assert_return(() => invoke($43, `test`, [27]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2399
+assert_return(() => invoke($43, `test`, [28]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2400
+assert_return(() => invoke($43, `test`, [29]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2401
+assert_return(() => invoke($43, `test`, [30]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2402
+assert_return(() => invoke($43, `test`, [31]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2404
+let $44 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 23)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7 $$f8)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2430
+assert_trap(() => invoke($44, `run`, [0, 23, 15]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2432
+assert_trap(() => invoke($44, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2433
+assert_trap(() => invoke($44, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2434
+assert_trap(() => invoke($44, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2435
+assert_trap(() => invoke($44, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2436
+assert_trap(() => invoke($44, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2437
+assert_trap(() => invoke($44, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2438
+assert_trap(() => invoke($44, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2439
+assert_trap(() => invoke($44, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2440
+assert_trap(() => invoke($44, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2441
+assert_trap(() => invoke($44, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2442
+assert_trap(() => invoke($44, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2443
+assert_trap(() => invoke($44, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2444
+assert_trap(() => invoke($44, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2445
+assert_trap(() => invoke($44, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2446
+assert_trap(() => invoke($44, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2447
+assert_trap(() => invoke($44, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2448
+assert_trap(() => invoke($44, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2449
+assert_trap(() => invoke($44, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2450
+assert_trap(() => invoke($44, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2451
+assert_trap(() => invoke($44, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2452
+assert_trap(() => invoke($44, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2453
+assert_trap(() => invoke($44, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2454
+assert_trap(() => invoke($44, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2455
+assert_return(() => invoke($44, `test`, [23]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2456
+assert_return(() => invoke($44, `test`, [24]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2457
+assert_return(() => invoke($44, `test`, [25]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2458
+assert_return(() => invoke($44, `test`, [26]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2459
+assert_return(() => invoke($44, `test`, [27]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2460
+assert_return(() => invoke($44, `test`, [28]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2461
+assert_return(() => invoke($44, `test`, [29]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2462
+assert_return(() => invoke($44, `test`, [30]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2463
+assert_return(() => invoke($44, `test`, [31]), [value("i32", 8)]);
+
+// ./test/core/table_copy.wast:2465
+let $45 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 11)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2491
+assert_trap(() => invoke($45, `run`, [24, 11, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2493
+assert_trap(() => invoke($45, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2494
+assert_trap(() => invoke($45, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2495
+assert_trap(() => invoke($45, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2496
+assert_trap(() => invoke($45, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2497
+assert_trap(() => invoke($45, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2498
+assert_trap(() => invoke($45, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2499
+assert_trap(() => invoke($45, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2500
+assert_trap(() => invoke($45, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2501
+assert_trap(() => invoke($45, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2502
+assert_trap(() => invoke($45, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2503
+assert_trap(() => invoke($45, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2504
+assert_return(() => invoke($45, `test`, [11]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2505
+assert_return(() => invoke($45, `test`, [12]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2506
+assert_return(() => invoke($45, `test`, [13]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2507
+assert_return(() => invoke($45, `test`, [14]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2508
+assert_return(() => invoke($45, `test`, [15]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2509
+assert_return(() => invoke($45, `test`, [16]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2510
+assert_return(() => invoke($45, `test`, [17]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2511
+assert_return(() => invoke($45, `test`, [18]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2512
+assert_trap(() => invoke($45, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2513
+assert_trap(() => invoke($45, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2514
+assert_trap(() => invoke($45, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2515
+assert_trap(() => invoke($45, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2516
+assert_trap(() => invoke($45, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2517
+assert_trap(() => invoke($45, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2518
+assert_trap(() => invoke($45, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2519
+assert_trap(() => invoke($45, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2520
+assert_trap(() => invoke($45, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2521
+assert_trap(() => invoke($45, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2522
+assert_trap(() => invoke($45, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2523
+assert_trap(() => invoke($45, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2524
+assert_trap(() => invoke($45, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2526
+let $46 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2552
+assert_trap(() => invoke($46, `run`, [11, 24, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2554
+assert_trap(() => invoke($46, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2555
+assert_trap(() => invoke($46, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2556
+assert_trap(() => invoke($46, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2557
+assert_trap(() => invoke($46, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2558
+assert_trap(() => invoke($46, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2559
+assert_trap(() => invoke($46, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2560
+assert_trap(() => invoke($46, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2561
+assert_trap(() => invoke($46, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2562
+assert_trap(() => invoke($46, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2563
+assert_trap(() => invoke($46, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2564
+assert_trap(() => invoke($46, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2565
+assert_trap(() => invoke($46, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2566
+assert_trap(() => invoke($46, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2567
+assert_trap(() => invoke($46, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2568
+assert_trap(() => invoke($46, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2569
+assert_trap(() => invoke($46, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2570
+assert_trap(() => invoke($46, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2571
+assert_trap(() => invoke($46, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2572
+assert_trap(() => invoke($46, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2573
+assert_trap(() => invoke($46, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2574
+assert_trap(() => invoke($46, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2575
+assert_trap(() => invoke($46, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2576
+assert_trap(() => invoke($46, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2577
+assert_trap(() => invoke($46, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2578
+assert_return(() => invoke($46, `test`, [24]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2579
+assert_return(() => invoke($46, `test`, [25]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2580
+assert_return(() => invoke($46, `test`, [26]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2581
+assert_return(() => invoke($46, `test`, [27]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2582
+assert_return(() => invoke($46, `test`, [28]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2583
+assert_return(() => invoke($46, `test`, [29]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2584
+assert_return(() => invoke($46, `test`, [30]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2585
+assert_return(() => invoke($46, `test`, [31]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2587
+let $47 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2613
+assert_trap(() => invoke($47, `run`, [24, 21, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2615
+assert_trap(() => invoke($47, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2616
+assert_trap(() => invoke($47, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2617
+assert_trap(() => invoke($47, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2618
+assert_trap(() => invoke($47, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2619
+assert_trap(() => invoke($47, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2620
+assert_trap(() => invoke($47, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2621
+assert_trap(() => invoke($47, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2622
+assert_trap(() => invoke($47, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2623
+assert_trap(() => invoke($47, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2624
+assert_trap(() => invoke($47, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2625
+assert_trap(() => invoke($47, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2626
+assert_trap(() => invoke($47, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2627
+assert_trap(() => invoke($47, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2628
+assert_trap(() => invoke($47, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2629
+assert_trap(() => invoke($47, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2630
+assert_trap(() => invoke($47, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2631
+assert_trap(() => invoke($47, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2632
+assert_trap(() => invoke($47, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2633
+assert_trap(() => invoke($47, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2634
+assert_trap(() => invoke($47, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2635
+assert_trap(() => invoke($47, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2636
+assert_return(() => invoke($47, `test`, [21]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2637
+assert_return(() => invoke($47, `test`, [22]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2638
+assert_return(() => invoke($47, `test`, [23]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2639
+assert_return(() => invoke($47, `test`, [24]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2640
+assert_return(() => invoke($47, `test`, [25]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2641
+assert_return(() => invoke($47, `test`, [26]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2642
+assert_return(() => invoke($47, `test`, [27]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2643
+assert_return(() => invoke($47, `test`, [28]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2644
+assert_trap(() => invoke($47, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2645
+assert_trap(() => invoke($47, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2646
+assert_trap(() => invoke($47, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2648
+let $48 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2674
+assert_trap(() => invoke($48, `run`, [21, 24, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2676
+assert_trap(() => invoke($48, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2677
+assert_trap(() => invoke($48, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2678
+assert_trap(() => invoke($48, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2679
+assert_trap(() => invoke($48, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2680
+assert_trap(() => invoke($48, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2681
+assert_trap(() => invoke($48, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2682
+assert_trap(() => invoke($48, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2683
+assert_trap(() => invoke($48, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2684
+assert_trap(() => invoke($48, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2685
+assert_trap(() => invoke($48, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2686
+assert_trap(() => invoke($48, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2687
+assert_trap(() => invoke($48, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2688
+assert_trap(() => invoke($48, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2689
+assert_trap(() => invoke($48, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2690
+assert_trap(() => invoke($48, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2691
+assert_trap(() => invoke($48, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2692
+assert_trap(() => invoke($48, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2693
+assert_trap(() => invoke($48, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2694
+assert_trap(() => invoke($48, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2695
+assert_trap(() => invoke($48, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2696
+assert_trap(() => invoke($48, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2697
+assert_trap(() => invoke($48, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2698
+assert_trap(() => invoke($48, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2699
+assert_trap(() => invoke($48, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2700
+assert_return(() => invoke($48, `test`, [24]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2701
+assert_return(() => invoke($48, `test`, [25]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2702
+assert_return(() => invoke($48, `test`, [26]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2703
+assert_return(() => invoke($48, `test`, [27]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2704
+assert_return(() => invoke($48, `test`, [28]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2705
+assert_return(() => invoke($48, `test`, [29]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2706
+assert_return(() => invoke($48, `test`, [30]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2707
+assert_return(() => invoke($48, `test`, [31]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2709
+let $49 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7 $$f8 $$f9 $$f10)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2735
+assert_trap(() => invoke($49, `run`, [21, 21, 16]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2737
+assert_trap(() => invoke($49, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2738
+assert_trap(() => invoke($49, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2739
+assert_trap(() => invoke($49, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2740
+assert_trap(() => invoke($49, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2741
+assert_trap(() => invoke($49, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2742
+assert_trap(() => invoke($49, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2743
+assert_trap(() => invoke($49, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2744
+assert_trap(() => invoke($49, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2745
+assert_trap(() => invoke($49, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2746
+assert_trap(() => invoke($49, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2747
+assert_trap(() => invoke($49, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2748
+assert_trap(() => invoke($49, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2749
+assert_trap(() => invoke($49, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2750
+assert_trap(() => invoke($49, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2751
+assert_trap(() => invoke($49, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2752
+assert_trap(() => invoke($49, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2753
+assert_trap(() => invoke($49, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2754
+assert_trap(() => invoke($49, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2755
+assert_trap(() => invoke($49, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2756
+assert_trap(() => invoke($49, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2757
+assert_trap(() => invoke($49, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2758
+assert_return(() => invoke($49, `test`, [21]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2759
+assert_return(() => invoke($49, `test`, [22]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2760
+assert_return(() => invoke($49, `test`, [23]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2761
+assert_return(() => invoke($49, `test`, [24]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2762
+assert_return(() => invoke($49, `test`, [25]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2763
+assert_return(() => invoke($49, `test`, [26]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2764
+assert_return(() => invoke($49, `test`, [27]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2765
+assert_return(() => invoke($49, `test`, [28]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2766
+assert_return(() => invoke($49, `test`, [29]), [value("i32", 8)]);
+
+// ./test/core/table_copy.wast:2767
+assert_return(() => invoke($49, `test`, [30]), [value("i32", 9)]);
+
+// ./test/core/table_copy.wast:2768
+assert_return(() => invoke($49, `test`, [31]), [value("i32", 10)]);
+
+// ./test/core/table_copy.wast:2770
+let $50 = instantiate(`(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 112)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7 $$f8 $$f9 $$f10 $$f11 $$f12 $$f13 $$f14 $$f15)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2796
+assert_trap(() => invoke($50, `run`, [0, 112, -32]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2798
+assert_trap(() => invoke($50, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2799
+assert_trap(() => invoke($50, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2800
+assert_trap(() => invoke($50, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2801
+assert_trap(() => invoke($50, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2802
+assert_trap(() => invoke($50, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2803
+assert_trap(() => invoke($50, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2804
+assert_trap(() => invoke($50, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2805
+assert_trap(() => invoke($50, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2806
+assert_trap(() => invoke($50, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2807
+assert_trap(() => invoke($50, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2808
+assert_trap(() => invoke($50, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2809
+assert_trap(() => invoke($50, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2810
+assert_trap(() => invoke($50, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2811
+assert_trap(() => invoke($50, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2812
+assert_trap(() => invoke($50, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2813
+assert_trap(() => invoke($50, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2814
+assert_trap(() => invoke($50, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2815
+assert_trap(() => invoke($50, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2816
+assert_trap(() => invoke($50, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2817
+assert_trap(() => invoke($50, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2818
+assert_trap(() => invoke($50, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2819
+assert_trap(() => invoke($50, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2820
+assert_trap(() => invoke($50, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2821
+assert_trap(() => invoke($50, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2822
+assert_trap(() => invoke($50, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2823
+assert_trap(() => invoke($50, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2824
+assert_trap(() => invoke($50, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2825
+assert_trap(() => invoke($50, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2826
+assert_trap(() => invoke($50, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2827
+assert_trap(() => invoke($50, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2828
+assert_trap(() => invoke($50, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2829
+assert_trap(() => invoke($50, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2830
+assert_trap(() => invoke($50, `test`, [32]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2831
+assert_trap(() => invoke($50, `test`, [33]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2832
+assert_trap(() => invoke($50, `test`, [34]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2833
+assert_trap(() => invoke($50, `test`, [35]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2834
+assert_trap(() => invoke($50, `test`, [36]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2835
+assert_trap(() => invoke($50, `test`, [37]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2836
+assert_trap(() => invoke($50, `test`, [38]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2837
+assert_trap(() => invoke($50, `test`, [39]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2838
+assert_trap(() => invoke($50, `test`, [40]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2839
+assert_trap(() => invoke($50, `test`, [41]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2840
+assert_trap(() => invoke($50, `test`, [42]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2841
+assert_trap(() => invoke($50, `test`, [43]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2842
+assert_trap(() => invoke($50, `test`, [44]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2843
+assert_trap(() => invoke($50, `test`, [45]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2844
+assert_trap(() => invoke($50, `test`, [46]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2845
+assert_trap(() => invoke($50, `test`, [47]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2846
+assert_trap(() => invoke($50, `test`, [48]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2847
+assert_trap(() => invoke($50, `test`, [49]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2848
+assert_trap(() => invoke($50, `test`, [50]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2849
+assert_trap(() => invoke($50, `test`, [51]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2850
+assert_trap(() => invoke($50, `test`, [52]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2851
+assert_trap(() => invoke($50, `test`, [53]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2852
+assert_trap(() => invoke($50, `test`, [54]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2853
+assert_trap(() => invoke($50, `test`, [55]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2854
+assert_trap(() => invoke($50, `test`, [56]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2855
+assert_trap(() => invoke($50, `test`, [57]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2856
+assert_trap(() => invoke($50, `test`, [58]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2857
+assert_trap(() => invoke($50, `test`, [59]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2858
+assert_trap(() => invoke($50, `test`, [60]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2859
+assert_trap(() => invoke($50, `test`, [61]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2860
+assert_trap(() => invoke($50, `test`, [62]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2861
+assert_trap(() => invoke($50, `test`, [63]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2862
+assert_trap(() => invoke($50, `test`, [64]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2863
+assert_trap(() => invoke($50, `test`, [65]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2864
+assert_trap(() => invoke($50, `test`, [66]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2865
+assert_trap(() => invoke($50, `test`, [67]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2866
+assert_trap(() => invoke($50, `test`, [68]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2867
+assert_trap(() => invoke($50, `test`, [69]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2868
+assert_trap(() => invoke($50, `test`, [70]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2869
+assert_trap(() => invoke($50, `test`, [71]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2870
+assert_trap(() => invoke($50, `test`, [72]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2871
+assert_trap(() => invoke($50, `test`, [73]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2872
+assert_trap(() => invoke($50, `test`, [74]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2873
+assert_trap(() => invoke($50, `test`, [75]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2874
+assert_trap(() => invoke($50, `test`, [76]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2875
+assert_trap(() => invoke($50, `test`, [77]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2876
+assert_trap(() => invoke($50, `test`, [78]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2877
+assert_trap(() => invoke($50, `test`, [79]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2878
+assert_trap(() => invoke($50, `test`, [80]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2879
+assert_trap(() => invoke($50, `test`, [81]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2880
+assert_trap(() => invoke($50, `test`, [82]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2881
+assert_trap(() => invoke($50, `test`, [83]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2882
+assert_trap(() => invoke($50, `test`, [84]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2883
+assert_trap(() => invoke($50, `test`, [85]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2884
+assert_trap(() => invoke($50, `test`, [86]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2885
+assert_trap(() => invoke($50, `test`, [87]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2886
+assert_trap(() => invoke($50, `test`, [88]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2887
+assert_trap(() => invoke($50, `test`, [89]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2888
+assert_trap(() => invoke($50, `test`, [90]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2889
+assert_trap(() => invoke($50, `test`, [91]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2890
+assert_trap(() => invoke($50, `test`, [92]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2891
+assert_trap(() => invoke($50, `test`, [93]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2892
+assert_trap(() => invoke($50, `test`, [94]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2893
+assert_trap(() => invoke($50, `test`, [95]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2894
+assert_trap(() => invoke($50, `test`, [96]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2895
+assert_trap(() => invoke($50, `test`, [97]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2896
+assert_trap(() => invoke($50, `test`, [98]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2897
+assert_trap(() => invoke($50, `test`, [99]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2898
+assert_trap(() => invoke($50, `test`, [100]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2899
+assert_trap(() => invoke($50, `test`, [101]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2900
+assert_trap(() => invoke($50, `test`, [102]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2901
+assert_trap(() => invoke($50, `test`, [103]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2902
+assert_trap(() => invoke($50, `test`, [104]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2903
+assert_trap(() => invoke($50, `test`, [105]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2904
+assert_trap(() => invoke($50, `test`, [106]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2905
+assert_trap(() => invoke($50, `test`, [107]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2906
+assert_trap(() => invoke($50, `test`, [108]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2907
+assert_trap(() => invoke($50, `test`, [109]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2908
+assert_trap(() => invoke($50, `test`, [110]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2909
+assert_trap(() => invoke($50, `test`, [111]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2910
+assert_return(() => invoke($50, `test`, [112]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2911
+assert_return(() => invoke($50, `test`, [113]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2912
+assert_return(() => invoke($50, `test`, [114]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2913
+assert_return(() => invoke($50, `test`, [115]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2914
+assert_return(() => invoke($50, `test`, [116]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2915
+assert_return(() => invoke($50, `test`, [117]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2916
+assert_return(() => invoke($50, `test`, [118]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2917
+assert_return(() => invoke($50, `test`, [119]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2918
+assert_return(() => invoke($50, `test`, [120]), [value("i32", 8)]);
+
+// ./test/core/table_copy.wast:2919
+assert_return(() => invoke($50, `test`, [121]), [value("i32", 9)]);
+
+// ./test/core/table_copy.wast:2920
+assert_return(() => invoke($50, `test`, [122]), [value("i32", 10)]);
+
+// ./test/core/table_copy.wast:2921
+assert_return(() => invoke($50, `test`, [123]), [value("i32", 11)]);
+
+// ./test/core/table_copy.wast:2922
+assert_return(() => invoke($50, `test`, [124]), [value("i32", 12)]);
+
+// ./test/core/table_copy.wast:2923
+assert_return(() => invoke($50, `test`, [125]), [value("i32", 13)]);
+
+// ./test/core/table_copy.wast:2924
+assert_return(() => invoke($50, `test`, [126]), [value("i32", 14)]);
+
+// ./test/core/table_copy.wast:2925
+assert_return(() => invoke($50, `test`, [127]), [value("i32", 15)]);
+
+// ./test/core/table_copy.wast:2927
+let $51 = instantiate(`(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 0)
+         $$f0 $$f1 $$f2 $$f3 $$f4 $$f5 $$f6 $$f7 $$f8 $$f9 $$f10 $$f11 $$f12 $$f13 $$f14 $$f15)
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$targetOffs i32) (param $$srcOffs i32) (param $$len i32)
+    (table.copy (local.get $$targetOffs) (local.get $$srcOffs) (local.get $$len))))`);
+
+// ./test/core/table_copy.wast:2953
+assert_trap(() => invoke($51, `run`, [112, 0, -32]), `out of bounds table access`);
+
+// ./test/core/table_copy.wast:2955
+assert_return(() => invoke($51, `test`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_copy.wast:2956
+assert_return(() => invoke($51, `test`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_copy.wast:2957
+assert_return(() => invoke($51, `test`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_copy.wast:2958
+assert_return(() => invoke($51, `test`, [3]), [value("i32", 3)]);
+
+// ./test/core/table_copy.wast:2959
+assert_return(() => invoke($51, `test`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_copy.wast:2960
+assert_return(() => invoke($51, `test`, [5]), [value("i32", 5)]);
+
+// ./test/core/table_copy.wast:2961
+assert_return(() => invoke($51, `test`, [6]), [value("i32", 6)]);
+
+// ./test/core/table_copy.wast:2962
+assert_return(() => invoke($51, `test`, [7]), [value("i32", 7)]);
+
+// ./test/core/table_copy.wast:2963
+assert_return(() => invoke($51, `test`, [8]), [value("i32", 8)]);
+
+// ./test/core/table_copy.wast:2964
+assert_return(() => invoke($51, `test`, [9]), [value("i32", 9)]);
+
+// ./test/core/table_copy.wast:2965
+assert_return(() => invoke($51, `test`, [10]), [value("i32", 10)]);
+
+// ./test/core/table_copy.wast:2966
+assert_return(() => invoke($51, `test`, [11]), [value("i32", 11)]);
+
+// ./test/core/table_copy.wast:2967
+assert_return(() => invoke($51, `test`, [12]), [value("i32", 12)]);
+
+// ./test/core/table_copy.wast:2968
+assert_return(() => invoke($51, `test`, [13]), [value("i32", 13)]);
+
+// ./test/core/table_copy.wast:2969
+assert_return(() => invoke($51, `test`, [14]), [value("i32", 14)]);
+
+// ./test/core/table_copy.wast:2970
+assert_return(() => invoke($51, `test`, [15]), [value("i32", 15)]);
+
+// ./test/core/table_copy.wast:2971
+assert_trap(() => invoke($51, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2972
+assert_trap(() => invoke($51, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2973
+assert_trap(() => invoke($51, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2974
+assert_trap(() => invoke($51, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2975
+assert_trap(() => invoke($51, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2976
+assert_trap(() => invoke($51, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2977
+assert_trap(() => invoke($51, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2978
+assert_trap(() => invoke($51, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2979
+assert_trap(() => invoke($51, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2980
+assert_trap(() => invoke($51, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2981
+assert_trap(() => invoke($51, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2982
+assert_trap(() => invoke($51, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2983
+assert_trap(() => invoke($51, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2984
+assert_trap(() => invoke($51, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2985
+assert_trap(() => invoke($51, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2986
+assert_trap(() => invoke($51, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2987
+assert_trap(() => invoke($51, `test`, [32]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2988
+assert_trap(() => invoke($51, `test`, [33]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2989
+assert_trap(() => invoke($51, `test`, [34]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2990
+assert_trap(() => invoke($51, `test`, [35]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2991
+assert_trap(() => invoke($51, `test`, [36]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2992
+assert_trap(() => invoke($51, `test`, [37]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2993
+assert_trap(() => invoke($51, `test`, [38]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2994
+assert_trap(() => invoke($51, `test`, [39]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2995
+assert_trap(() => invoke($51, `test`, [40]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2996
+assert_trap(() => invoke($51, `test`, [41]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2997
+assert_trap(() => invoke($51, `test`, [42]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2998
+assert_trap(() => invoke($51, `test`, [43]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:2999
+assert_trap(() => invoke($51, `test`, [44]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3000
+assert_trap(() => invoke($51, `test`, [45]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3001
+assert_trap(() => invoke($51, `test`, [46]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3002
+assert_trap(() => invoke($51, `test`, [47]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3003
+assert_trap(() => invoke($51, `test`, [48]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3004
+assert_trap(() => invoke($51, `test`, [49]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3005
+assert_trap(() => invoke($51, `test`, [50]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3006
+assert_trap(() => invoke($51, `test`, [51]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3007
+assert_trap(() => invoke($51, `test`, [52]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3008
+assert_trap(() => invoke($51, `test`, [53]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3009
+assert_trap(() => invoke($51, `test`, [54]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3010
+assert_trap(() => invoke($51, `test`, [55]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3011
+assert_trap(() => invoke($51, `test`, [56]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3012
+assert_trap(() => invoke($51, `test`, [57]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3013
+assert_trap(() => invoke($51, `test`, [58]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3014
+assert_trap(() => invoke($51, `test`, [59]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3015
+assert_trap(() => invoke($51, `test`, [60]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3016
+assert_trap(() => invoke($51, `test`, [61]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3017
+assert_trap(() => invoke($51, `test`, [62]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3018
+assert_trap(() => invoke($51, `test`, [63]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3019
+assert_trap(() => invoke($51, `test`, [64]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3020
+assert_trap(() => invoke($51, `test`, [65]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3021
+assert_trap(() => invoke($51, `test`, [66]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3022
+assert_trap(() => invoke($51, `test`, [67]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3023
+assert_trap(() => invoke($51, `test`, [68]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3024
+assert_trap(() => invoke($51, `test`, [69]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3025
+assert_trap(() => invoke($51, `test`, [70]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3026
+assert_trap(() => invoke($51, `test`, [71]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3027
+assert_trap(() => invoke($51, `test`, [72]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3028
+assert_trap(() => invoke($51, `test`, [73]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3029
+assert_trap(() => invoke($51, `test`, [74]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3030
+assert_trap(() => invoke($51, `test`, [75]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3031
+assert_trap(() => invoke($51, `test`, [76]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3032
+assert_trap(() => invoke($51, `test`, [77]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3033
+assert_trap(() => invoke($51, `test`, [78]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3034
+assert_trap(() => invoke($51, `test`, [79]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3035
+assert_trap(() => invoke($51, `test`, [80]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3036
+assert_trap(() => invoke($51, `test`, [81]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3037
+assert_trap(() => invoke($51, `test`, [82]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3038
+assert_trap(() => invoke($51, `test`, [83]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3039
+assert_trap(() => invoke($51, `test`, [84]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3040
+assert_trap(() => invoke($51, `test`, [85]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3041
+assert_trap(() => invoke($51, `test`, [86]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3042
+assert_trap(() => invoke($51, `test`, [87]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3043
+assert_trap(() => invoke($51, `test`, [88]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3044
+assert_trap(() => invoke($51, `test`, [89]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3045
+assert_trap(() => invoke($51, `test`, [90]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3046
+assert_trap(() => invoke($51, `test`, [91]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3047
+assert_trap(() => invoke($51, `test`, [92]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3048
+assert_trap(() => invoke($51, `test`, [93]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3049
+assert_trap(() => invoke($51, `test`, [94]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3050
+assert_trap(() => invoke($51, `test`, [95]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3051
+assert_trap(() => invoke($51, `test`, [96]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3052
+assert_trap(() => invoke($51, `test`, [97]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3053
+assert_trap(() => invoke($51, `test`, [98]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3054
+assert_trap(() => invoke($51, `test`, [99]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3055
+assert_trap(() => invoke($51, `test`, [100]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3056
+assert_trap(() => invoke($51, `test`, [101]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3057
+assert_trap(() => invoke($51, `test`, [102]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3058
+assert_trap(() => invoke($51, `test`, [103]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3059
+assert_trap(() => invoke($51, `test`, [104]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3060
+assert_trap(() => invoke($51, `test`, [105]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3061
+assert_trap(() => invoke($51, `test`, [106]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3062
+assert_trap(() => invoke($51, `test`, [107]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3063
+assert_trap(() => invoke($51, `test`, [108]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3064
+assert_trap(() => invoke($51, `test`, [109]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3065
+assert_trap(() => invoke($51, `test`, [110]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3066
+assert_trap(() => invoke($51, `test`, [111]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3067
+assert_trap(() => invoke($51, `test`, [112]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3068
+assert_trap(() => invoke($51, `test`, [113]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3069
+assert_trap(() => invoke($51, `test`, [114]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3070
+assert_trap(() => invoke($51, `test`, [115]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3071
+assert_trap(() => invoke($51, `test`, [116]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3072
+assert_trap(() => invoke($51, `test`, [117]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3073
+assert_trap(() => invoke($51, `test`, [118]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3074
+assert_trap(() => invoke($51, `test`, [119]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3075
+assert_trap(() => invoke($51, `test`, [120]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3076
+assert_trap(() => invoke($51, `test`, [121]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3077
+assert_trap(() => invoke($51, `test`, [122]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3078
+assert_trap(() => invoke($51, `test`, [123]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3079
+assert_trap(() => invoke($51, `test`, [124]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3080
+assert_trap(() => invoke($51, `test`, [125]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3081
+assert_trap(() => invoke($51, `test`, [126]), `uninitialized element`);
+
+// ./test/core/table_copy.wast:3082
+assert_trap(() => invoke($51, `test`, [127]), `uninitialized element`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_fill.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_fill.wast.js
new file mode 100644
index 0000000000..1063554a94
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_fill.wast.js
@@ -0,0 +1,238 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_fill.wast
+
+// ./test/core/table_fill.wast:1
+let $0 = instantiate(`(module
+  (table $$t 10 externref)
+
+  (func (export "fill") (param $$i i32) (param $$r externref) (param $$n i32)
+    (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))
+  )
+)`);
+
+// ./test/core/table_fill.wast:17
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:18
+assert_return(() => invoke($0, `get`, [2]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:19
+assert_return(() => invoke($0, `get`, [3]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:20
+assert_return(() => invoke($0, `get`, [4]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:21
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:23
+assert_return(() => invoke($0, `fill`, [2, externref(1), 3]), []);
+
+// ./test/core/table_fill.wast:24
+assert_return(() => invoke($0, `get`, [1]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:25
+assert_return(() => invoke($0, `get`, [2]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:26
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:27
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:28
+assert_return(() => invoke($0, `get`, [5]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:30
+assert_return(() => invoke($0, `fill`, [4, externref(2), 2]), []);
+
+// ./test/core/table_fill.wast:31
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:32
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:33
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:34
+assert_return(() => invoke($0, `get`, [6]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:36
+assert_return(() => invoke($0, `fill`, [4, externref(3), 0]), []);
+
+// ./test/core/table_fill.wast:37
+assert_return(() => invoke($0, `get`, [3]), [value('externref', externref(1))]);
+
+// ./test/core/table_fill.wast:38
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:39
+assert_return(() => invoke($0, `get`, [5]), [value('externref', externref(2))]);
+
+// ./test/core/table_fill.wast:41
+assert_return(() => invoke($0, `fill`, [8, externref(4), 2]), []);
+
+// ./test/core/table_fill.wast:42
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:43
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:44
+assert_return(() => invoke($0, `get`, [9]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:46
+assert_return(() => invoke($0, `fill-abbrev`, [9, null, 1]), []);
+
+// ./test/core/table_fill.wast:47
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:48
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:50
+assert_return(() => invoke($0, `fill`, [10, externref(5), 0]), []);
+
+// ./test/core/table_fill.wast:51
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:53
+assert_trap(() => invoke($0, `fill`, [8, externref(6), 3]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:57
+assert_return(() => invoke($0, `get`, [7]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:58
+assert_return(() => invoke($0, `get`, [8]), [value('externref', externref(4))]);
+
+// ./test/core/table_fill.wast:59
+assert_return(() => invoke($0, `get`, [9]), [value('externref', null)]);
+
+// ./test/core/table_fill.wast:61
+assert_trap(() => invoke($0, `fill`, [11, null, 0]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:66
+assert_trap(() => invoke($0, `fill`, [11, null, 10]), `out of bounds table access`);
+
+// ./test/core/table_fill.wast:74
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-value-length-empty-vs-i32-i32
+      (table.fill $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:83
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32
+      (table.fill $$t (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:92
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-value-empty-vs
+      (table.fill $$t (i32.const 1) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:101
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-length-empty-vs-i32
+      (table.fill $$t (i32.const 1) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:110
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-index-f32-vs-i32
+      (table.fill $$t (f32.const 1) (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:119
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 funcref)
+    (func $$type-value-vs-funcref (param $$r externref)
+      (table.fill $$t (i32.const 1) (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:128
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-length-f32-vs-i32
+      (table.fill $$t (i32.const 1) (ref.null extern) (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:138
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 externref)
+    (table $$t2 1 funcref)
+    (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+      (table.fill $$t2 (i32.const 0) (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_fill.wast:149
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-empty-vs-num (result i32)
+      (table.fill $$t (i32.const 0) (ref.null extern) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_get.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_get.wast.js
new file mode 100644
index 0000000000..9b2adc86e3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_get.wast.js
@@ -0,0 +1,126 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_get.wast
+
+// ./test/core/table_get.wast:1
+let $0 = instantiate(`(module
+  (table $$t2 2 externref)
+  (table $$t3 3 funcref)
+  (elem (table $$t3) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "init") (param $$r externref)
+    (table.set $$t2 (i32.const 1) (local.get $$r))
+    (table.set $$t3 (i32.const 2) (table.get $$t3 (i32.const 1)))
+  )
+
+  (func (export "get-externref") (param $$i i32) (result externref)
+    (table.get (local.get $$i))
+  )
+  (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+    (table.get $$t3 (local.get $$i))
+  )
+
+  (func (export "is_null-funcref") (param $$i i32) (result i32)
+    (ref.is_null (call $$f3 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/table_get.wast:24
+invoke($0, `init`, [externref(1)]);
+
+// ./test/core/table_get.wast:26
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_get.wast:27
+assert_return(() => invoke($0, `get-externref`, [1]), [value('externref', externref(1))]);
+
+// ./test/core/table_get.wast:29
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_get.wast:30
+assert_return(() => invoke($0, `is_null-funcref`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:31
+assert_return(() => invoke($0, `is_null-funcref`, [2]), [value("i32", 0)]);
+
+// ./test/core/table_get.wast:33
+assert_trap(() => invoke($0, `get-externref`, [2]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:34
+assert_trap(() => invoke($0, `get-funcref`, [3]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:35
+assert_trap(() => invoke($0, `get-externref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:36
+assert_trap(() => invoke($0, `get-funcref`, [-1]), `out of bounds table access`);
+
+// ./test/core/table_get.wast:41
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32 (result externref)
+      (table.get $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:50
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-f32-vs-i32 (result externref)
+      (table.get $$t (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:60
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-externref-vs-empty
+      (table.get $$t (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:69
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-externref-vs-funcref (result funcref)
+      (table.get $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_get.wast:79
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 funcref)
+    (table $$t2 1 externref)
+    (func $$type-result-externref-vs-funcref-multi (result funcref)
+      (table.get $$t2 (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_grow.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_grow.wast.js
new file mode 100644
index 0000000000..be505bd261
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_grow.wast.js
@@ -0,0 +1,271 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_grow.wast
+
+// ./test/core/table_grow.wast:1
+let $0 = instantiate(`(module
+  (table $$t 0 externref)
+
+  (func (export "get") (param $$i i32) (result externref) (table.get $$t (local.get $$i)))
+  (func (export "set") (param $$i i32) (param $$r externref) (table.set $$t (local.get $$i) (local.get $$r)))
+
+  (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))
+)`);
+
+// ./test/core/table_grow.wast:16
+assert_return(() => invoke($0, `size`, []), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:17
+assert_trap(() => invoke($0, `set`, [0, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:18
+assert_trap(() => invoke($0, `get`, [0]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:20
+assert_return(() => invoke($0, `grow`, [1, null]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:21
+assert_return(() => invoke($0, `size`, []), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:22
+assert_return(() => invoke($0, `get`, [0]), [value('externref', null)]);
+
+// ./test/core/table_grow.wast:23
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:24
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:25
+assert_trap(() => invoke($0, `set`, [1, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:26
+assert_trap(() => invoke($0, `get`, [1]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:28
+assert_return(() => invoke($0, `grow-abbrev`, [4, externref(3)]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:29
+assert_return(() => invoke($0, `size`, []), [value("i32", 5)]);
+
+// ./test/core/table_grow.wast:30
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:31
+assert_return(() => invoke($0, `set`, [0, externref(2)]), []);
+
+// ./test/core/table_grow.wast:32
+assert_return(() => invoke($0, `get`, [0]), [value('externref', externref(2))]);
+
+// ./test/core/table_grow.wast:33
+assert_return(() => invoke($0, `get`, [1]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:34
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(3))]);
+
+// ./test/core/table_grow.wast:35
+assert_return(() => invoke($0, `set`, [4, externref(4)]), []);
+
+// ./test/core/table_grow.wast:36
+assert_return(() => invoke($0, `get`, [4]), [value('externref', externref(4))]);
+
+// ./test/core/table_grow.wast:37
+assert_trap(() => invoke($0, `set`, [5, externref(2)]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:38
+assert_trap(() => invoke($0, `get`, [5]), `out of bounds table access`);
+
+// ./test/core/table_grow.wast:42
+let $1 = instantiate(`(module
+  (table $$t 0x10 funcref)
+  (elem declare func $$f)
+  (func $$f (export "grow") (result i32)
+    (table.grow $$t (ref.func $$f) (i32.const 0xffff_fff0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:50
+assert_return(() => invoke($1, `grow`, []), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:53
+let $2 = instantiate(`(module
+  (table $$t 0 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null extern) (local.get 0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:60
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:61
+assert_return(() => invoke($2, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:62
+assert_return(() => invoke($2, `grow`, [0]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:63
+assert_return(() => invoke($2, `grow`, [2]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:64
+assert_return(() => invoke($2, `grow`, [800]), [value("i32", 3)]);
+
+// ./test/core/table_grow.wast:67
+let $3 = instantiate(`(module
+  (table $$t 0 10 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null extern) (local.get 0))
+  )
+)`);
+
+// ./test/core/table_grow.wast:74
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:75
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 0)]);
+
+// ./test/core/table_grow.wast:76
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", 1)]);
+
+// ./test/core/table_grow.wast:77
+assert_return(() => invoke($3, `grow`, [2]), [value("i32", 2)]);
+
+// ./test/core/table_grow.wast:78
+assert_return(() => invoke($3, `grow`, [6]), [value("i32", 4)]);
+
+// ./test/core/table_grow.wast:79
+assert_return(() => invoke($3, `grow`, [0]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:80
+assert_return(() => invoke($3, `grow`, [1]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:81
+assert_return(() => invoke($3, `grow`, [65536]), [value("i32", -1)]);
+
+// ./test/core/table_grow.wast:84
+let $4 = instantiate(`(module
+  (table $$t 10 funcref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $$t (ref.null func) (local.get 0))
+  )
+  (elem declare func 1)
+  (func (export "check-table-null") (param i32 i32) (result funcref)
+    (local funcref)
+    (local.set 2 (ref.func 1))
+    (block
+      (loop
+        (local.set 2 (table.get $$t (local.get 0)))
+        (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)`);
+
+// ./test/core/table_grow.wast:106
+assert_return(() => invoke($4, `check-table-null`, [0, 9]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:107
+assert_return(() => invoke($4, `grow`, [10]), [value("i32", 10)]);
+
+// ./test/core/table_grow.wast:108
+assert_return(() => invoke($4, `check-table-null`, [0, 19]), [value('anyfunc', null)]);
+
+// ./test/core/table_grow.wast:113
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-init-size-empty-vs-i32-externref (result i32)
+      (table.grow $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:122
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-size-empty-vs-i32 (result i32)
+      (table.grow $$t (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:131
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-init-empty-vs-externref (result i32)
+      (table.grow $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:140
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 externref)
+    (func $$type-size-f32-vs-i32 (result i32)
+      (table.grow $$t (ref.null extern) (f32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:149
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 0 funcref)
+    (func $$type-init-externref-vs-funcref (param $$r externref) (result i32)
+      (table.grow $$t (local.get $$r) (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:159
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-empty
+      (table.grow $$t (ref.null extern) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_grow.wast:168
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (table.grow $$t (ref.null extern) (i32.const 0))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_init.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_init.wast.js
new file mode 100644
index 0000000000..a9457bbb2c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_init.wast.js
@@ -0,0 +1,3674 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_init.wast
+
+// ./test/core/table_init.wast:6
+let $0 = instantiate(`(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)`);
+
+// ./test/core/table_init.wast:13
+register($0, `a`);
+
+// ./test/core/table_init.wast:15
+let $1 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_init.wast:41
+invoke($1, `test`, []);
+
+// ./test/core/table_init.wast:42
+assert_trap(() => invoke($1, `check`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:43
+assert_trap(() => invoke($1, `check`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:44
+assert_return(() => invoke($1, `check`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:45
+assert_return(() => invoke($1, `check`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:46
+assert_return(() => invoke($1, `check`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_init.wast:47
+assert_return(() => invoke($1, `check`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:48
+assert_trap(() => invoke($1, `check`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:49
+assert_return(() => invoke($1, `check`, [7]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:50
+assert_return(() => invoke($1, `check`, [8]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:51
+assert_return(() => invoke($1, `check`, [9]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:52
+assert_return(() => invoke($1, `check`, [10]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:53
+assert_trap(() => invoke($1, `check`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:54
+assert_return(() => invoke($1, `check`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:55
+assert_return(() => invoke($1, `check`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_init.wast:56
+assert_return(() => invoke($1, `check`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:57
+assert_return(() => invoke($1, `check`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:58
+assert_return(() => invoke($1, `check`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_init.wast:59
+assert_trap(() => invoke($1, `check`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:60
+assert_trap(() => invoke($1, `check`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:61
+assert_trap(() => invoke($1, `check`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:62
+assert_trap(() => invoke($1, `check`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:63
+assert_trap(() => invoke($1, `check`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:64
+assert_trap(() => invoke($1, `check`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:65
+assert_trap(() => invoke($1, `check`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:66
+assert_trap(() => invoke($1, `check`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:67
+assert_trap(() => invoke($1, `check`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:68
+assert_trap(() => invoke($1, `check`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:69
+assert_trap(() => invoke($1, `check`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:70
+assert_trap(() => invoke($1, `check`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:71
+assert_trap(() => invoke($1, `check`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:73
+let $2 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $$t0 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_init.wast:99
+invoke($2, `test`, []);
+
+// ./test/core/table_init.wast:100
+assert_trap(() => invoke($2, `check`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:101
+assert_trap(() => invoke($2, `check`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:102
+assert_return(() => invoke($2, `check`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:103
+assert_return(() => invoke($2, `check`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:104
+assert_return(() => invoke($2, `check`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_init.wast:105
+assert_return(() => invoke($2, `check`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:106
+assert_trap(() => invoke($2, `check`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:107
+assert_trap(() => invoke($2, `check`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:108
+assert_trap(() => invoke($2, `check`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:109
+assert_trap(() => invoke($2, `check`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:110
+assert_trap(() => invoke($2, `check`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:111
+assert_trap(() => invoke($2, `check`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:112
+assert_return(() => invoke($2, `check`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:113
+assert_return(() => invoke($2, `check`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_init.wast:114
+assert_return(() => invoke($2, `check`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:115
+assert_return(() => invoke($2, `check`, [15]), [value("i32", 9)]);
+
+// ./test/core/table_init.wast:116
+assert_return(() => invoke($2, `check`, [16]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:117
+assert_return(() => invoke($2, `check`, [17]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:118
+assert_trap(() => invoke($2, `check`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:119
+assert_trap(() => invoke($2, `check`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:120
+assert_trap(() => invoke($2, `check`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:121
+assert_trap(() => invoke($2, `check`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:122
+assert_trap(() => invoke($2, `check`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:123
+assert_trap(() => invoke($2, `check`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:124
+assert_trap(() => invoke($2, `check`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:125
+assert_trap(() => invoke($2, `check`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:126
+assert_trap(() => invoke($2, `check`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:127
+assert_trap(() => invoke($2, `check`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:128
+assert_trap(() => invoke($2, `check`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:129
+assert_trap(() => invoke($2, `check`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:131
+let $3 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 7) (i32.const 0) (i32.const 4))
+         (elem.drop 1)
+         (table.init $$t0 3 (i32.const 15) (i32.const 1) (i32.const 3))
+         (elem.drop 3)
+         (table.copy $$t0 0 (i32.const 20) (i32.const 15) (i32.const 5))
+         (table.copy $$t0 0 (i32.const 21) (i32.const 29) (i32.const 1))
+         (table.copy $$t0 0 (i32.const 24) (i32.const 10) (i32.const 1))
+         (table.copy $$t0 0 (i32.const 13) (i32.const 11) (i32.const 4))
+         (table.copy $$t0 0 (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $$t0 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_init.wast:165
+invoke($3, `test`, []);
+
+// ./test/core/table_init.wast:166
+assert_trap(() => invoke($3, `check`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:167
+assert_trap(() => invoke($3, `check`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:168
+assert_return(() => invoke($3, `check`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:169
+assert_return(() => invoke($3, `check`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:170
+assert_return(() => invoke($3, `check`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_init.wast:171
+assert_return(() => invoke($3, `check`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:172
+assert_trap(() => invoke($3, `check`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:173
+assert_return(() => invoke($3, `check`, [7]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:174
+assert_return(() => invoke($3, `check`, [8]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:175
+assert_return(() => invoke($3, `check`, [9]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:176
+assert_return(() => invoke($3, `check`, [10]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:177
+assert_trap(() => invoke($3, `check`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:178
+assert_return(() => invoke($3, `check`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:179
+assert_trap(() => invoke($3, `check`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:180
+assert_return(() => invoke($3, `check`, [14]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:181
+assert_return(() => invoke($3, `check`, [15]), [value("i32", 5)]);
+
+// ./test/core/table_init.wast:182
+assert_return(() => invoke($3, `check`, [16]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:183
+assert_return(() => invoke($3, `check`, [17]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:184
+assert_trap(() => invoke($3, `check`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:185
+assert_return(() => invoke($3, `check`, [19]), [value("i32", 9)]);
+
+// ./test/core/table_init.wast:186
+assert_trap(() => invoke($3, `check`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:187
+assert_return(() => invoke($3, `check`, [21]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:188
+assert_trap(() => invoke($3, `check`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:189
+assert_return(() => invoke($3, `check`, [23]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:190
+assert_return(() => invoke($3, `check`, [24]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:191
+assert_trap(() => invoke($3, `check`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:192
+assert_trap(() => invoke($3, `check`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:193
+assert_trap(() => invoke($3, `check`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:194
+assert_trap(() => invoke($3, `check`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:195
+assert_trap(() => invoke($3, `check`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:197
+let $4 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_init.wast:223
+invoke($4, `test`, []);
+
+// ./test/core/table_init.wast:224
+assert_trap(() => invoke($4, `check`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:225
+assert_trap(() => invoke($4, `check`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:226
+assert_return(() => invoke($4, `check`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:227
+assert_return(() => invoke($4, `check`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:228
+assert_return(() => invoke($4, `check`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_init.wast:229
+assert_return(() => invoke($4, `check`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:230
+assert_trap(() => invoke($4, `check`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:231
+assert_return(() => invoke($4, `check`, [7]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:232
+assert_return(() => invoke($4, `check`, [8]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:233
+assert_return(() => invoke($4, `check`, [9]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:234
+assert_return(() => invoke($4, `check`, [10]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:235
+assert_trap(() => invoke($4, `check`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:236
+assert_return(() => invoke($4, `check`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:237
+assert_return(() => invoke($4, `check`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_init.wast:238
+assert_return(() => invoke($4, `check`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:239
+assert_return(() => invoke($4, `check`, [15]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:240
+assert_return(() => invoke($4, `check`, [16]), [value("i32", 6)]);
+
+// ./test/core/table_init.wast:241
+assert_trap(() => invoke($4, `check`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:242
+assert_trap(() => invoke($4, `check`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:243
+assert_trap(() => invoke($4, `check`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:244
+assert_trap(() => invoke($4, `check`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:245
+assert_trap(() => invoke($4, `check`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:246
+assert_trap(() => invoke($4, `check`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:247
+assert_trap(() => invoke($4, `check`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:248
+assert_trap(() => invoke($4, `check`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:249
+assert_trap(() => invoke($4, `check`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:250
+assert_trap(() => invoke($4, `check`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:251
+assert_trap(() => invoke($4, `check`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:252
+assert_trap(() => invoke($4, `check`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:253
+assert_trap(() => invoke($4, `check`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:255
+let $5 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $$t1 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_init.wast:281
+invoke($5, `test`, []);
+
+// ./test/core/table_init.wast:282
+assert_trap(() => invoke($5, `check`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:283
+assert_trap(() => invoke($5, `check`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:284
+assert_return(() => invoke($5, `check`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:285
+assert_return(() => invoke($5, `check`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:286
+assert_return(() => invoke($5, `check`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_init.wast:287
+assert_return(() => invoke($5, `check`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:288
+assert_trap(() => invoke($5, `check`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:289
+assert_trap(() => invoke($5, `check`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:290
+assert_trap(() => invoke($5, `check`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:291
+assert_trap(() => invoke($5, `check`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:292
+assert_trap(() => invoke($5, `check`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:293
+assert_trap(() => invoke($5, `check`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:294
+assert_return(() => invoke($5, `check`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:295
+assert_return(() => invoke($5, `check`, [13]), [value("i32", 5)]);
+
+// ./test/core/table_init.wast:296
+assert_return(() => invoke($5, `check`, [14]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:297
+assert_return(() => invoke($5, `check`, [15]), [value("i32", 9)]);
+
+// ./test/core/table_init.wast:298
+assert_return(() => invoke($5, `check`, [16]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:299
+assert_return(() => invoke($5, `check`, [17]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:300
+assert_trap(() => invoke($5, `check`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:301
+assert_trap(() => invoke($5, `check`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:302
+assert_trap(() => invoke($5, `check`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:303
+assert_trap(() => invoke($5, `check`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:304
+assert_trap(() => invoke($5, `check`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:305
+assert_trap(() => invoke($5, `check`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:306
+assert_trap(() => invoke($5, `check`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:307
+assert_trap(() => invoke($5, `check`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:308
+assert_trap(() => invoke($5, `check`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:309
+assert_trap(() => invoke($5, `check`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:310
+assert_trap(() => invoke($5, `check`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:311
+assert_trap(() => invoke($5, `check`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:313
+let $6 = instantiate(`(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $$t0 30 30 funcref)
+  (table $$t1 30 30 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 7) (i32.const 0) (i32.const 4))
+         (elem.drop 1)
+         (table.init $$t1 3 (i32.const 15) (i32.const 1) (i32.const 3))
+         (elem.drop 3)
+         (table.copy $$t1 1 (i32.const 20) (i32.const 15) (i32.const 5))
+         (table.copy $$t1 1 (i32.const 21) (i32.const 29) (i32.const 1))
+         (table.copy $$t1 1 (i32.const 24) (i32.const 10) (i32.const 1))
+         (table.copy $$t1 1 (i32.const 13) (i32.const 11) (i32.const 4))
+         (table.copy $$t1 1 (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $$t1 (type 0) (local.get 0)))
+)`);
+
+// ./test/core/table_init.wast:347
+invoke($6, `test`, []);
+
+// ./test/core/table_init.wast:348
+assert_trap(() => invoke($6, `check`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:349
+assert_trap(() => invoke($6, `check`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:350
+assert_return(() => invoke($6, `check`, [2]), [value("i32", 3)]);
+
+// ./test/core/table_init.wast:351
+assert_return(() => invoke($6, `check`, [3]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:352
+assert_return(() => invoke($6, `check`, [4]), [value("i32", 4)]);
+
+// ./test/core/table_init.wast:353
+assert_return(() => invoke($6, `check`, [5]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:354
+assert_trap(() => invoke($6, `check`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:355
+assert_return(() => invoke($6, `check`, [7]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:356
+assert_return(() => invoke($6, `check`, [8]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:357
+assert_return(() => invoke($6, `check`, [9]), [value("i32", 1)]);
+
+// ./test/core/table_init.wast:358
+assert_return(() => invoke($6, `check`, [10]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:359
+assert_trap(() => invoke($6, `check`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:360
+assert_return(() => invoke($6, `check`, [12]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:361
+assert_trap(() => invoke($6, `check`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:362
+assert_return(() => invoke($6, `check`, [14]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:363
+assert_return(() => invoke($6, `check`, [15]), [value("i32", 5)]);
+
+// ./test/core/table_init.wast:364
+assert_return(() => invoke($6, `check`, [16]), [value("i32", 2)]);
+
+// ./test/core/table_init.wast:365
+assert_return(() => invoke($6, `check`, [17]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:366
+assert_trap(() => invoke($6, `check`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:367
+assert_return(() => invoke($6, `check`, [19]), [value("i32", 9)]);
+
+// ./test/core/table_init.wast:368
+assert_trap(() => invoke($6, `check`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:369
+assert_return(() => invoke($6, `check`, [21]), [value("i32", 7)]);
+
+// ./test/core/table_init.wast:370
+assert_trap(() => invoke($6, `check`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:371
+assert_return(() => invoke($6, `check`, [23]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:372
+assert_return(() => invoke($6, `check`, [24]), [value("i32", 8)]);
+
+// ./test/core/table_init.wast:373
+assert_trap(() => invoke($6, `check`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:374
+assert_trap(() => invoke($6, `check`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:375
+assert_trap(() => invoke($6, `check`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:376
+assert_trap(() => invoke($6, `check`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:377
+assert_trap(() => invoke($6, `check`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:378
+assert_invalid(
+  () => instantiate(`(module
+    (func (export "test")
+      (elem.drop 0)))`),
+  `unknown elem segment 0`,
+);
+
+// ./test/core/table_init.wast:384
+assert_invalid(
+  () => instantiate(`(module
+    (func (export "test")
+      (table.init 0 (i32.const 12) (i32.const 1) (i32.const 1))))`),
+  `unknown table 0`,
+);
+
+// ./test/core/table_init.wast:390
+assert_invalid(
+  () => instantiate(`(module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (elem.drop 4)))`),
+  `unknown elem segment 4`,
+);
+
+// ./test/core/table_init.wast:398
+assert_invalid(
+  () => instantiate(`(module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (table.init 4 (i32.const 12) (i32.const 1) (i32.const 1))))`),
+  `unknown table 0`,
+);
+
+// ./test/core/table_init.wast:407
+let $7 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 2)
+    ))`);
+
+// ./test/core/table_init.wast:429
+invoke($7, `test`, []);
+
+// ./test/core/table_init.wast:431
+let $8 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))
+    ))`);
+
+// ./test/core/table_init.wast:453
+assert_trap(() => invoke($8, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:455
+let $9 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))
+    (table.init 1 (i32.const 21) (i32.const 1) (i32.const 1))))`);
+
+// ./test/core/table_init.wast:477
+invoke($9, `test`, []);
+
+// ./test/core/table_init.wast:479
+let $10 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (elem.drop 1)))`);
+
+// ./test/core/table_init.wast:501
+invoke($10, `test`, []);
+
+// ./test/core/table_init.wast:503
+let $11 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))))`);
+
+// ./test/core/table_init.wast:525
+assert_trap(() => invoke($11, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:527
+let $12 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))
+    ))`);
+
+// ./test/core/table_init.wast:549
+assert_trap(() => invoke($12, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:551
+let $13 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))
+    ))`);
+
+// ./test/core/table_init.wast:573
+assert_trap(() => invoke($13, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:575
+let $14 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))`);
+
+// ./test/core/table_init.wast:597
+assert_trap(() => invoke($14, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:599
+let $15 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:621
+invoke($15, `test`, []);
+
+// ./test/core/table_init.wast:623
+let $16 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:645
+assert_trap(() => invoke($16, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:647
+let $17 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 30) (i32.const 2) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:669
+invoke($17, `test`, []);
+
+// ./test/core/table_init.wast:671
+let $18 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 31) (i32.const 2) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:693
+assert_trap(() => invoke($18, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:695
+let $19 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 30) (i32.const 4) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:717
+invoke($19, `test`, []);
+
+// ./test/core/table_init.wast:719
+let $20 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t0 1 (i32.const 31) (i32.const 5) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:741
+assert_trap(() => invoke($20, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:743
+let $21 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 26) (i32.const 1) (i32.const 3))
+    ))`);
+
+// ./test/core/table_init.wast:765
+assert_trap(() => invoke($21, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:767
+let $22 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:789
+invoke($22, `test`, []);
+
+// ./test/core/table_init.wast:791
+let $23 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:813
+assert_trap(() => invoke($23, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:815
+let $24 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 28) (i32.const 2) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:837
+invoke($24, `test`, []);
+
+// ./test/core/table_init.wast:839
+let $25 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 29) (i32.const 2) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:861
+assert_trap(() => invoke($25, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:863
+let $26 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 28) (i32.const 4) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:885
+invoke($26, `test`, []);
+
+// ./test/core/table_init.wast:887
+let $27 = instantiate(`(module
+  (table $$t0 30 30 funcref)
+  (table $$t1 28 28 funcref)
+  (elem (table $$t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $$t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $$t1 1 (i32.const 29) (i32.const 5) (i32.const 0))
+    ))`);
+
+// ./test/core/table_init.wast:909
+assert_trap(() => invoke($27, `test`, []), `out of bounds table access`);
+
+// ./test/core/table_init.wast:911
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:920
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:929
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:938
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:947
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:956
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:965
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:974
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:983
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:992
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1001
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1010
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1019
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1028
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1037
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1046
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1055
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1064
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1073
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1082
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1091
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1100
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1109
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1118
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1127
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1136
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1145
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1154
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1163
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1172
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1181
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1190
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1199
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1208
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1217
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1226
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1235
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1244
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1253
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1262
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1271
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1280
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1289
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1298
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1307
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1316
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1325
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1334
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1343
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1352
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1361
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1370
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1379
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1388
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1397
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1406
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1415
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1424
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1433
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1442
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1451
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1460
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1469
+assert_invalid(
+  () => instantiate(`(module
+    (table 10 funcref)
+    (elem funcref (ref.func $$f0) (ref.func $$f0) (ref.func $$f0))
+    (func $$f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))`),
+  `type mismatch`,
+);
+
+// ./test/core/table_init.wast:1478
+let $28 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $$f0) (ref.func $$f1) (ref.func $$f2) (ref.func $$f3)
+    (ref.func $$f4) (ref.func $$f5) (ref.func $$f6) (ref.func $$f7)
+    (ref.func $$f8) (ref.func $$f9) (ref.func $$f10) (ref.func $$f11)
+    (ref.func $$f12) (ref.func $$f13) (ref.func $$f14) (ref.func $$f15))
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (table.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/table_init.wast:1506
+assert_trap(() => invoke($28, `run`, [24, 16]), `out of bounds table access`);
+
+// ./test/core/table_init.wast:1507
+assert_trap(() => invoke($28, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1508
+assert_trap(() => invoke($28, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1509
+assert_trap(() => invoke($28, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1510
+assert_trap(() => invoke($28, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1511
+assert_trap(() => invoke($28, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1512
+assert_trap(() => invoke($28, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1513
+assert_trap(() => invoke($28, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1514
+assert_trap(() => invoke($28, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1515
+assert_trap(() => invoke($28, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1516
+assert_trap(() => invoke($28, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1517
+assert_trap(() => invoke($28, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1518
+assert_trap(() => invoke($28, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1519
+assert_trap(() => invoke($28, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1520
+assert_trap(() => invoke($28, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1521
+assert_trap(() => invoke($28, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1522
+assert_trap(() => invoke($28, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1523
+assert_trap(() => invoke($28, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1524
+assert_trap(() => invoke($28, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1525
+assert_trap(() => invoke($28, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1526
+assert_trap(() => invoke($28, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1527
+assert_trap(() => invoke($28, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1528
+assert_trap(() => invoke($28, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1529
+assert_trap(() => invoke($28, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1530
+assert_trap(() => invoke($28, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1531
+assert_trap(() => invoke($28, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1532
+assert_trap(() => invoke($28, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1533
+assert_trap(() => invoke($28, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1534
+assert_trap(() => invoke($28, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1535
+assert_trap(() => invoke($28, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1536
+assert_trap(() => invoke($28, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1537
+assert_trap(() => invoke($28, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1538
+assert_trap(() => invoke($28, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1540
+let $29 = instantiate(`(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $$f0) (ref.func $$f1) (ref.func $$f2) (ref.func $$f3)
+    (ref.func $$f4) (ref.func $$f5) (ref.func $$f6) (ref.func $$f7)
+    (ref.func $$f8) (ref.func $$f9) (ref.func $$f10) (ref.func $$f11)
+    (ref.func $$f12) (ref.func $$f13) (ref.func $$f14) (ref.func $$f15))
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (table.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/table_init.wast:1568
+assert_trap(() => invoke($29, `run`, [25, 16]), `out of bounds table access`);
+
+// ./test/core/table_init.wast:1569
+assert_trap(() => invoke($29, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1570
+assert_trap(() => invoke($29, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1571
+assert_trap(() => invoke($29, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1572
+assert_trap(() => invoke($29, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1573
+assert_trap(() => invoke($29, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1574
+assert_trap(() => invoke($29, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1575
+assert_trap(() => invoke($29, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1576
+assert_trap(() => invoke($29, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1577
+assert_trap(() => invoke($29, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1578
+assert_trap(() => invoke($29, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1579
+assert_trap(() => invoke($29, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1580
+assert_trap(() => invoke($29, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1581
+assert_trap(() => invoke($29, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1582
+assert_trap(() => invoke($29, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1583
+assert_trap(() => invoke($29, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1584
+assert_trap(() => invoke($29, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1585
+assert_trap(() => invoke($29, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1586
+assert_trap(() => invoke($29, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1587
+assert_trap(() => invoke($29, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1588
+assert_trap(() => invoke($29, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1589
+assert_trap(() => invoke($29, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1590
+assert_trap(() => invoke($29, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1591
+assert_trap(() => invoke($29, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1592
+assert_trap(() => invoke($29, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1593
+assert_trap(() => invoke($29, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1594
+assert_trap(() => invoke($29, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1595
+assert_trap(() => invoke($29, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1596
+assert_trap(() => invoke($29, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1597
+assert_trap(() => invoke($29, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1598
+assert_trap(() => invoke($29, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1599
+assert_trap(() => invoke($29, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1600
+assert_trap(() => invoke($29, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1602
+let $30 = instantiate(`(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $$f0) (ref.func $$f1) (ref.func $$f2) (ref.func $$f3)
+    (ref.func $$f4) (ref.func $$f5) (ref.func $$f6) (ref.func $$f7)
+    (ref.func $$f8) (ref.func $$f9) (ref.func $$f10) (ref.func $$f11)
+    (ref.func $$f12) (ref.func $$f13) (ref.func $$f14) (ref.func $$f15))
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (table.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/table_init.wast:1630
+assert_trap(() => invoke($30, `run`, [96, 32]), `out of bounds table access`);
+
+// ./test/core/table_init.wast:1631
+assert_trap(() => invoke($30, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1632
+assert_trap(() => invoke($30, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1633
+assert_trap(() => invoke($30, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1634
+assert_trap(() => invoke($30, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1635
+assert_trap(() => invoke($30, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1636
+assert_trap(() => invoke($30, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1637
+assert_trap(() => invoke($30, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1638
+assert_trap(() => invoke($30, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1639
+assert_trap(() => invoke($30, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1640
+assert_trap(() => invoke($30, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1641
+assert_trap(() => invoke($30, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1642
+assert_trap(() => invoke($30, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1643
+assert_trap(() => invoke($30, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1644
+assert_trap(() => invoke($30, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1645
+assert_trap(() => invoke($30, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1646
+assert_trap(() => invoke($30, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1647
+assert_trap(() => invoke($30, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1648
+assert_trap(() => invoke($30, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1649
+assert_trap(() => invoke($30, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1650
+assert_trap(() => invoke($30, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1651
+assert_trap(() => invoke($30, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1652
+assert_trap(() => invoke($30, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1653
+assert_trap(() => invoke($30, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1654
+assert_trap(() => invoke($30, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1655
+assert_trap(() => invoke($30, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1656
+assert_trap(() => invoke($30, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1657
+assert_trap(() => invoke($30, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1658
+assert_trap(() => invoke($30, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1659
+assert_trap(() => invoke($30, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1660
+assert_trap(() => invoke($30, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1661
+assert_trap(() => invoke($30, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1662
+assert_trap(() => invoke($30, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1663
+assert_trap(() => invoke($30, `test`, [32]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1664
+assert_trap(() => invoke($30, `test`, [33]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1665
+assert_trap(() => invoke($30, `test`, [34]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1666
+assert_trap(() => invoke($30, `test`, [35]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1667
+assert_trap(() => invoke($30, `test`, [36]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1668
+assert_trap(() => invoke($30, `test`, [37]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1669
+assert_trap(() => invoke($30, `test`, [38]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1670
+assert_trap(() => invoke($30, `test`, [39]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1671
+assert_trap(() => invoke($30, `test`, [40]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1672
+assert_trap(() => invoke($30, `test`, [41]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1673
+assert_trap(() => invoke($30, `test`, [42]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1674
+assert_trap(() => invoke($30, `test`, [43]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1675
+assert_trap(() => invoke($30, `test`, [44]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1676
+assert_trap(() => invoke($30, `test`, [45]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1677
+assert_trap(() => invoke($30, `test`, [46]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1678
+assert_trap(() => invoke($30, `test`, [47]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1679
+assert_trap(() => invoke($30, `test`, [48]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1680
+assert_trap(() => invoke($30, `test`, [49]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1681
+assert_trap(() => invoke($30, `test`, [50]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1682
+assert_trap(() => invoke($30, `test`, [51]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1683
+assert_trap(() => invoke($30, `test`, [52]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1684
+assert_trap(() => invoke($30, `test`, [53]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1685
+assert_trap(() => invoke($30, `test`, [54]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1686
+assert_trap(() => invoke($30, `test`, [55]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1687
+assert_trap(() => invoke($30, `test`, [56]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1688
+assert_trap(() => invoke($30, `test`, [57]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1689
+assert_trap(() => invoke($30, `test`, [58]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1690
+assert_trap(() => invoke($30, `test`, [59]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1691
+assert_trap(() => invoke($30, `test`, [60]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1692
+assert_trap(() => invoke($30, `test`, [61]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1693
+assert_trap(() => invoke($30, `test`, [62]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1694
+assert_trap(() => invoke($30, `test`, [63]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1695
+assert_trap(() => invoke($30, `test`, [64]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1696
+assert_trap(() => invoke($30, `test`, [65]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1697
+assert_trap(() => invoke($30, `test`, [66]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1698
+assert_trap(() => invoke($30, `test`, [67]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1699
+assert_trap(() => invoke($30, `test`, [68]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1700
+assert_trap(() => invoke($30, `test`, [69]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1701
+assert_trap(() => invoke($30, `test`, [70]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1702
+assert_trap(() => invoke($30, `test`, [71]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1703
+assert_trap(() => invoke($30, `test`, [72]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1704
+assert_trap(() => invoke($30, `test`, [73]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1705
+assert_trap(() => invoke($30, `test`, [74]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1706
+assert_trap(() => invoke($30, `test`, [75]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1707
+assert_trap(() => invoke($30, `test`, [76]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1708
+assert_trap(() => invoke($30, `test`, [77]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1709
+assert_trap(() => invoke($30, `test`, [78]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1710
+assert_trap(() => invoke($30, `test`, [79]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1711
+assert_trap(() => invoke($30, `test`, [80]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1712
+assert_trap(() => invoke($30, `test`, [81]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1713
+assert_trap(() => invoke($30, `test`, [82]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1714
+assert_trap(() => invoke($30, `test`, [83]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1715
+assert_trap(() => invoke($30, `test`, [84]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1716
+assert_trap(() => invoke($30, `test`, [85]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1717
+assert_trap(() => invoke($30, `test`, [86]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1718
+assert_trap(() => invoke($30, `test`, [87]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1719
+assert_trap(() => invoke($30, `test`, [88]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1720
+assert_trap(() => invoke($30, `test`, [89]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1721
+assert_trap(() => invoke($30, `test`, [90]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1722
+assert_trap(() => invoke($30, `test`, [91]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1723
+assert_trap(() => invoke($30, `test`, [92]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1724
+assert_trap(() => invoke($30, `test`, [93]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1725
+assert_trap(() => invoke($30, `test`, [94]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1726
+assert_trap(() => invoke($30, `test`, [95]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1727
+assert_trap(() => invoke($30, `test`, [96]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1728
+assert_trap(() => invoke($30, `test`, [97]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1729
+assert_trap(() => invoke($30, `test`, [98]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1730
+assert_trap(() => invoke($30, `test`, [99]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1731
+assert_trap(() => invoke($30, `test`, [100]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1732
+assert_trap(() => invoke($30, `test`, [101]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1733
+assert_trap(() => invoke($30, `test`, [102]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1734
+assert_trap(() => invoke($30, `test`, [103]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1735
+assert_trap(() => invoke($30, `test`, [104]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1736
+assert_trap(() => invoke($30, `test`, [105]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1737
+assert_trap(() => invoke($30, `test`, [106]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1738
+assert_trap(() => invoke($30, `test`, [107]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1739
+assert_trap(() => invoke($30, `test`, [108]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1740
+assert_trap(() => invoke($30, `test`, [109]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1741
+assert_trap(() => invoke($30, `test`, [110]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1742
+assert_trap(() => invoke($30, `test`, [111]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1743
+assert_trap(() => invoke($30, `test`, [112]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1744
+assert_trap(() => invoke($30, `test`, [113]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1745
+assert_trap(() => invoke($30, `test`, [114]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1746
+assert_trap(() => invoke($30, `test`, [115]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1747
+assert_trap(() => invoke($30, `test`, [116]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1748
+assert_trap(() => invoke($30, `test`, [117]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1749
+assert_trap(() => invoke($30, `test`, [118]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1750
+assert_trap(() => invoke($30, `test`, [119]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1751
+assert_trap(() => invoke($30, `test`, [120]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1752
+assert_trap(() => invoke($30, `test`, [121]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1753
+assert_trap(() => invoke($30, `test`, [122]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1754
+assert_trap(() => invoke($30, `test`, [123]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1755
+assert_trap(() => invoke($30, `test`, [124]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1756
+assert_trap(() => invoke($30, `test`, [125]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1757
+assert_trap(() => invoke($30, `test`, [126]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1758
+assert_trap(() => invoke($30, `test`, [127]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1759
+assert_trap(() => invoke($30, `test`, [128]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1760
+assert_trap(() => invoke($30, `test`, [129]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1761
+assert_trap(() => invoke($30, `test`, [130]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1762
+assert_trap(() => invoke($30, `test`, [131]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1763
+assert_trap(() => invoke($30, `test`, [132]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1764
+assert_trap(() => invoke($30, `test`, [133]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1765
+assert_trap(() => invoke($30, `test`, [134]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1766
+assert_trap(() => invoke($30, `test`, [135]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1767
+assert_trap(() => invoke($30, `test`, [136]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1768
+assert_trap(() => invoke($30, `test`, [137]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1769
+assert_trap(() => invoke($30, `test`, [138]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1770
+assert_trap(() => invoke($30, `test`, [139]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1771
+assert_trap(() => invoke($30, `test`, [140]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1772
+assert_trap(() => invoke($30, `test`, [141]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1773
+assert_trap(() => invoke($30, `test`, [142]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1774
+assert_trap(() => invoke($30, `test`, [143]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1775
+assert_trap(() => invoke($30, `test`, [144]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1776
+assert_trap(() => invoke($30, `test`, [145]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1777
+assert_trap(() => invoke($30, `test`, [146]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1778
+assert_trap(() => invoke($30, `test`, [147]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1779
+assert_trap(() => invoke($30, `test`, [148]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1780
+assert_trap(() => invoke($30, `test`, [149]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1781
+assert_trap(() => invoke($30, `test`, [150]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1782
+assert_trap(() => invoke($30, `test`, [151]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1783
+assert_trap(() => invoke($30, `test`, [152]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1784
+assert_trap(() => invoke($30, `test`, [153]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1785
+assert_trap(() => invoke($30, `test`, [154]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1786
+assert_trap(() => invoke($30, `test`, [155]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1787
+assert_trap(() => invoke($30, `test`, [156]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1788
+assert_trap(() => invoke($30, `test`, [157]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1789
+assert_trap(() => invoke($30, `test`, [158]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1790
+assert_trap(() => invoke($30, `test`, [159]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1792
+let $31 = instantiate(`(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $$f0) (ref.func $$f1) (ref.func $$f2) (ref.func $$f3)
+    (ref.func $$f4) (ref.func $$f5) (ref.func $$f6) (ref.func $$f7)
+    (ref.func $$f8) (ref.func $$f9) (ref.func $$f10) (ref.func $$f11)
+    (ref.func $$f12) (ref.func $$f13) (ref.func $$f14) (ref.func $$f15))
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (table.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/table_init.wast:1820
+assert_trap(() => invoke($31, `run`, [97, 31]), `out of bounds table access`);
+
+// ./test/core/table_init.wast:1821
+assert_trap(() => invoke($31, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1822
+assert_trap(() => invoke($31, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1823
+assert_trap(() => invoke($31, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1824
+assert_trap(() => invoke($31, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1825
+assert_trap(() => invoke($31, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1826
+assert_trap(() => invoke($31, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1827
+assert_trap(() => invoke($31, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1828
+assert_trap(() => invoke($31, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1829
+assert_trap(() => invoke($31, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1830
+assert_trap(() => invoke($31, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1831
+assert_trap(() => invoke($31, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1832
+assert_trap(() => invoke($31, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1833
+assert_trap(() => invoke($31, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1834
+assert_trap(() => invoke($31, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1835
+assert_trap(() => invoke($31, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1836
+assert_trap(() => invoke($31, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1837
+assert_trap(() => invoke($31, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1838
+assert_trap(() => invoke($31, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1839
+assert_trap(() => invoke($31, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1840
+assert_trap(() => invoke($31, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1841
+assert_trap(() => invoke($31, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1842
+assert_trap(() => invoke($31, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1843
+assert_trap(() => invoke($31, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1844
+assert_trap(() => invoke($31, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1845
+assert_trap(() => invoke($31, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1846
+assert_trap(() => invoke($31, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1847
+assert_trap(() => invoke($31, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1848
+assert_trap(() => invoke($31, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1849
+assert_trap(() => invoke($31, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1850
+assert_trap(() => invoke($31, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1851
+assert_trap(() => invoke($31, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1852
+assert_trap(() => invoke($31, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1853
+assert_trap(() => invoke($31, `test`, [32]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1854
+assert_trap(() => invoke($31, `test`, [33]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1855
+assert_trap(() => invoke($31, `test`, [34]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1856
+assert_trap(() => invoke($31, `test`, [35]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1857
+assert_trap(() => invoke($31, `test`, [36]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1858
+assert_trap(() => invoke($31, `test`, [37]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1859
+assert_trap(() => invoke($31, `test`, [38]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1860
+assert_trap(() => invoke($31, `test`, [39]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1861
+assert_trap(() => invoke($31, `test`, [40]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1862
+assert_trap(() => invoke($31, `test`, [41]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1863
+assert_trap(() => invoke($31, `test`, [42]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1864
+assert_trap(() => invoke($31, `test`, [43]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1865
+assert_trap(() => invoke($31, `test`, [44]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1866
+assert_trap(() => invoke($31, `test`, [45]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1867
+assert_trap(() => invoke($31, `test`, [46]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1868
+assert_trap(() => invoke($31, `test`, [47]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1869
+assert_trap(() => invoke($31, `test`, [48]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1870
+assert_trap(() => invoke($31, `test`, [49]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1871
+assert_trap(() => invoke($31, `test`, [50]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1872
+assert_trap(() => invoke($31, `test`, [51]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1873
+assert_trap(() => invoke($31, `test`, [52]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1874
+assert_trap(() => invoke($31, `test`, [53]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1875
+assert_trap(() => invoke($31, `test`, [54]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1876
+assert_trap(() => invoke($31, `test`, [55]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1877
+assert_trap(() => invoke($31, `test`, [56]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1878
+assert_trap(() => invoke($31, `test`, [57]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1879
+assert_trap(() => invoke($31, `test`, [58]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1880
+assert_trap(() => invoke($31, `test`, [59]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1881
+assert_trap(() => invoke($31, `test`, [60]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1882
+assert_trap(() => invoke($31, `test`, [61]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1883
+assert_trap(() => invoke($31, `test`, [62]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1884
+assert_trap(() => invoke($31, `test`, [63]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1885
+assert_trap(() => invoke($31, `test`, [64]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1886
+assert_trap(() => invoke($31, `test`, [65]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1887
+assert_trap(() => invoke($31, `test`, [66]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1888
+assert_trap(() => invoke($31, `test`, [67]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1889
+assert_trap(() => invoke($31, `test`, [68]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1890
+assert_trap(() => invoke($31, `test`, [69]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1891
+assert_trap(() => invoke($31, `test`, [70]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1892
+assert_trap(() => invoke($31, `test`, [71]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1893
+assert_trap(() => invoke($31, `test`, [72]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1894
+assert_trap(() => invoke($31, `test`, [73]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1895
+assert_trap(() => invoke($31, `test`, [74]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1896
+assert_trap(() => invoke($31, `test`, [75]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1897
+assert_trap(() => invoke($31, `test`, [76]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1898
+assert_trap(() => invoke($31, `test`, [77]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1899
+assert_trap(() => invoke($31, `test`, [78]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1900
+assert_trap(() => invoke($31, `test`, [79]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1901
+assert_trap(() => invoke($31, `test`, [80]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1902
+assert_trap(() => invoke($31, `test`, [81]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1903
+assert_trap(() => invoke($31, `test`, [82]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1904
+assert_trap(() => invoke($31, `test`, [83]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1905
+assert_trap(() => invoke($31, `test`, [84]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1906
+assert_trap(() => invoke($31, `test`, [85]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1907
+assert_trap(() => invoke($31, `test`, [86]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1908
+assert_trap(() => invoke($31, `test`, [87]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1909
+assert_trap(() => invoke($31, `test`, [88]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1910
+assert_trap(() => invoke($31, `test`, [89]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1911
+assert_trap(() => invoke($31, `test`, [90]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1912
+assert_trap(() => invoke($31, `test`, [91]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1913
+assert_trap(() => invoke($31, `test`, [92]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1914
+assert_trap(() => invoke($31, `test`, [93]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1915
+assert_trap(() => invoke($31, `test`, [94]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1916
+assert_trap(() => invoke($31, `test`, [95]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1917
+assert_trap(() => invoke($31, `test`, [96]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1918
+assert_trap(() => invoke($31, `test`, [97]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1919
+assert_trap(() => invoke($31, `test`, [98]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1920
+assert_trap(() => invoke($31, `test`, [99]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1921
+assert_trap(() => invoke($31, `test`, [100]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1922
+assert_trap(() => invoke($31, `test`, [101]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1923
+assert_trap(() => invoke($31, `test`, [102]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1924
+assert_trap(() => invoke($31, `test`, [103]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1925
+assert_trap(() => invoke($31, `test`, [104]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1926
+assert_trap(() => invoke($31, `test`, [105]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1927
+assert_trap(() => invoke($31, `test`, [106]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1928
+assert_trap(() => invoke($31, `test`, [107]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1929
+assert_trap(() => invoke($31, `test`, [108]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1930
+assert_trap(() => invoke($31, `test`, [109]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1931
+assert_trap(() => invoke($31, `test`, [110]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1932
+assert_trap(() => invoke($31, `test`, [111]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1933
+assert_trap(() => invoke($31, `test`, [112]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1934
+assert_trap(() => invoke($31, `test`, [113]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1935
+assert_trap(() => invoke($31, `test`, [114]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1936
+assert_trap(() => invoke($31, `test`, [115]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1937
+assert_trap(() => invoke($31, `test`, [116]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1938
+assert_trap(() => invoke($31, `test`, [117]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1939
+assert_trap(() => invoke($31, `test`, [118]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1940
+assert_trap(() => invoke($31, `test`, [119]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1941
+assert_trap(() => invoke($31, `test`, [120]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1942
+assert_trap(() => invoke($31, `test`, [121]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1943
+assert_trap(() => invoke($31, `test`, [122]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1944
+assert_trap(() => invoke($31, `test`, [123]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1945
+assert_trap(() => invoke($31, `test`, [124]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1946
+assert_trap(() => invoke($31, `test`, [125]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1947
+assert_trap(() => invoke($31, `test`, [126]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1948
+assert_trap(() => invoke($31, `test`, [127]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1949
+assert_trap(() => invoke($31, `test`, [128]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1950
+assert_trap(() => invoke($31, `test`, [129]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1951
+assert_trap(() => invoke($31, `test`, [130]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1952
+assert_trap(() => invoke($31, `test`, [131]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1953
+assert_trap(() => invoke($31, `test`, [132]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1954
+assert_trap(() => invoke($31, `test`, [133]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1955
+assert_trap(() => invoke($31, `test`, [134]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1956
+assert_trap(() => invoke($31, `test`, [135]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1957
+assert_trap(() => invoke($31, `test`, [136]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1958
+assert_trap(() => invoke($31, `test`, [137]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1959
+assert_trap(() => invoke($31, `test`, [138]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1960
+assert_trap(() => invoke($31, `test`, [139]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1961
+assert_trap(() => invoke($31, `test`, [140]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1962
+assert_trap(() => invoke($31, `test`, [141]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1963
+assert_trap(() => invoke($31, `test`, [142]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1964
+assert_trap(() => invoke($31, `test`, [143]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1965
+assert_trap(() => invoke($31, `test`, [144]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1966
+assert_trap(() => invoke($31, `test`, [145]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1967
+assert_trap(() => invoke($31, `test`, [146]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1968
+assert_trap(() => invoke($31, `test`, [147]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1969
+assert_trap(() => invoke($31, `test`, [148]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1970
+assert_trap(() => invoke($31, `test`, [149]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1971
+assert_trap(() => invoke($31, `test`, [150]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1972
+assert_trap(() => invoke($31, `test`, [151]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1973
+assert_trap(() => invoke($31, `test`, [152]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1974
+assert_trap(() => invoke($31, `test`, [153]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1975
+assert_trap(() => invoke($31, `test`, [154]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1976
+assert_trap(() => invoke($31, `test`, [155]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1977
+assert_trap(() => invoke($31, `test`, [156]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1978
+assert_trap(() => invoke($31, `test`, [157]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1979
+assert_trap(() => invoke($31, `test`, [158]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1980
+assert_trap(() => invoke($31, `test`, [159]), `uninitialized element`);
+
+// ./test/core/table_init.wast:1982
+let $32 = instantiate(`(module
+  (type (func (result i32)))
+  (table 64 64 funcref)
+  (elem funcref
+    (ref.func $$f0) (ref.func $$f1) (ref.func $$f2) (ref.func $$f3)
+    (ref.func $$f4) (ref.func $$f5) (ref.func $$f6) (ref.func $$f7)
+    (ref.func $$f8) (ref.func $$f9) (ref.func $$f10) (ref.func $$f11)
+    (ref.func $$f12) (ref.func $$f13) (ref.func $$f14) (ref.func $$f15))
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (table.init 0 (local.get $$offs) (i32.const 0) (local.get $$len))))`);
+
+// ./test/core/table_init.wast:2010
+assert_trap(() => invoke($32, `run`, [48, -16]), `out of bounds table access`);
+
+// ./test/core/table_init.wast:2011
+assert_trap(() => invoke($32, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2012
+assert_trap(() => invoke($32, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2013
+assert_trap(() => invoke($32, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2014
+assert_trap(() => invoke($32, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2015
+assert_trap(() => invoke($32, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2016
+assert_trap(() => invoke($32, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2017
+assert_trap(() => invoke($32, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2018
+assert_trap(() => invoke($32, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2019
+assert_trap(() => invoke($32, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2020
+assert_trap(() => invoke($32, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2021
+assert_trap(() => invoke($32, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2022
+assert_trap(() => invoke($32, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2023
+assert_trap(() => invoke($32, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2024
+assert_trap(() => invoke($32, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2025
+assert_trap(() => invoke($32, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2026
+assert_trap(() => invoke($32, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2027
+assert_trap(() => invoke($32, `test`, [16]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2028
+assert_trap(() => invoke($32, `test`, [17]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2029
+assert_trap(() => invoke($32, `test`, [18]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2030
+assert_trap(() => invoke($32, `test`, [19]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2031
+assert_trap(() => invoke($32, `test`, [20]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2032
+assert_trap(() => invoke($32, `test`, [21]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2033
+assert_trap(() => invoke($32, `test`, [22]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2034
+assert_trap(() => invoke($32, `test`, [23]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2035
+assert_trap(() => invoke($32, `test`, [24]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2036
+assert_trap(() => invoke($32, `test`, [25]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2037
+assert_trap(() => invoke($32, `test`, [26]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2038
+assert_trap(() => invoke($32, `test`, [27]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2039
+assert_trap(() => invoke($32, `test`, [28]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2040
+assert_trap(() => invoke($32, `test`, [29]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2041
+assert_trap(() => invoke($32, `test`, [30]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2042
+assert_trap(() => invoke($32, `test`, [31]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2043
+assert_trap(() => invoke($32, `test`, [32]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2044
+assert_trap(() => invoke($32, `test`, [33]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2045
+assert_trap(() => invoke($32, `test`, [34]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2046
+assert_trap(() => invoke($32, `test`, [35]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2047
+assert_trap(() => invoke($32, `test`, [36]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2048
+assert_trap(() => invoke($32, `test`, [37]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2049
+assert_trap(() => invoke($32, `test`, [38]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2050
+assert_trap(() => invoke($32, `test`, [39]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2051
+assert_trap(() => invoke($32, `test`, [40]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2052
+assert_trap(() => invoke($32, `test`, [41]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2053
+assert_trap(() => invoke($32, `test`, [42]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2054
+assert_trap(() => invoke($32, `test`, [43]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2055
+assert_trap(() => invoke($32, `test`, [44]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2056
+assert_trap(() => invoke($32, `test`, [45]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2057
+assert_trap(() => invoke($32, `test`, [46]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2058
+assert_trap(() => invoke($32, `test`, [47]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2059
+assert_trap(() => invoke($32, `test`, [48]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2060
+assert_trap(() => invoke($32, `test`, [49]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2061
+assert_trap(() => invoke($32, `test`, [50]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2062
+assert_trap(() => invoke($32, `test`, [51]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2063
+assert_trap(() => invoke($32, `test`, [52]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2064
+assert_trap(() => invoke($32, `test`, [53]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2065
+assert_trap(() => invoke($32, `test`, [54]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2066
+assert_trap(() => invoke($32, `test`, [55]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2067
+assert_trap(() => invoke($32, `test`, [56]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2068
+assert_trap(() => invoke($32, `test`, [57]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2069
+assert_trap(() => invoke($32, `test`, [58]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2070
+assert_trap(() => invoke($32, `test`, [59]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2071
+assert_trap(() => invoke($32, `test`, [60]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2072
+assert_trap(() => invoke($32, `test`, [61]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2073
+assert_trap(() => invoke($32, `test`, [62]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2074
+assert_trap(() => invoke($32, `test`, [63]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2076
+let $33 = instantiate(`(module
+  (type (func (result i32)))
+  (table 16 16 funcref)
+  (elem funcref
+    (ref.func $$f0) (ref.func $$f1) (ref.func $$f2) (ref.func $$f3)
+    (ref.func $$f4) (ref.func $$f5) (ref.func $$f6) (ref.func $$f7)
+    (ref.func $$f8) (ref.func $$f9) (ref.func $$f10) (ref.func $$f11)
+    (ref.func $$f12) (ref.func $$f13) (ref.func $$f14) (ref.func $$f15))
+  (func $$f0 (export "f0") (result i32) (i32.const 0))
+  (func $$f1 (export "f1") (result i32) (i32.const 1))
+  (func $$f2 (export "f2") (result i32) (i32.const 2))
+  (func $$f3 (export "f3") (result i32) (i32.const 3))
+  (func $$f4 (export "f4") (result i32) (i32.const 4))
+  (func $$f5 (export "f5") (result i32) (i32.const 5))
+  (func $$f6 (export "f6") (result i32) (i32.const 6))
+  (func $$f7 (export "f7") (result i32) (i32.const 7))
+  (func $$f8 (export "f8") (result i32) (i32.const 8))
+  (func $$f9 (export "f9") (result i32) (i32.const 9))
+  (func $$f10 (export "f10") (result i32) (i32.const 10))
+  (func $$f11 (export "f11") (result i32) (i32.const 11))
+  (func $$f12 (export "f12") (result i32) (i32.const 12))
+  (func $$f13 (export "f13") (result i32) (i32.const 13))
+  (func $$f14 (export "f14") (result i32) (i32.const 14))
+  (func $$f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $$n i32) (result i32)
+    (call_indirect (type 0) (local.get $$n)))
+  (func (export "run") (param $$offs i32) (param $$len i32)
+    (table.init 0 (local.get $$offs) (i32.const 8) (local.get $$len))))`);
+
+// ./test/core/table_init.wast:2104
+assert_trap(() => invoke($33, `run`, [0, -4]), `out of bounds table access`);
+
+// ./test/core/table_init.wast:2105
+assert_trap(() => invoke($33, `test`, [0]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2106
+assert_trap(() => invoke($33, `test`, [1]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2107
+assert_trap(() => invoke($33, `test`, [2]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2108
+assert_trap(() => invoke($33, `test`, [3]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2109
+assert_trap(() => invoke($33, `test`, [4]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2110
+assert_trap(() => invoke($33, `test`, [5]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2111
+assert_trap(() => invoke($33, `test`, [6]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2112
+assert_trap(() => invoke($33, `test`, [7]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2113
+assert_trap(() => invoke($33, `test`, [8]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2114
+assert_trap(() => invoke($33, `test`, [9]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2115
+assert_trap(() => invoke($33, `test`, [10]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2116
+assert_trap(() => invoke($33, `test`, [11]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2117
+assert_trap(() => invoke($33, `test`, [12]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2118
+assert_trap(() => invoke($33, `test`, [13]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2119
+assert_trap(() => invoke($33, `test`, [14]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2120
+assert_trap(() => invoke($33, `test`, [15]), `uninitialized element`);
+
+// ./test/core/table_init.wast:2122
+let $34 = instantiate(`(module
+  (table 1 funcref)
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (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))))`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_set.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_set.wast.js
new file mode 100644
index 0000000000..667f7eb973
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_set.wast.js
@@ -0,0 +1,177 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_set.wast
+
+// ./test/core/table_set.wast:1
+let $0 = instantiate(`(module
+  (table $$t2 1 externref)
+  (table $$t3 2 funcref)
+  (elem (table $$t3) (i32.const 1) func $$dummy)
+  (func $$dummy)
+
+  (func (export "get-externref") (param $$i i32) (result externref)
+    (table.get $$t2 (local.get $$i))
+  )
+  (func $$f3 (export "get-funcref") (param $$i i32) (result funcref)
+    (table.get $$t3 (local.get $$i))
+  )
+
+  (func (export "set-externref") (param $$i i32) (param $$r externref)
+    (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))
+  )
+  (func (export "set-funcref-from") (param $$i i32) (param $$j i32)
+    (table.set $$t3 (local.get $$i) (table.get $$t3 (local.get $$j)))
+  )
+
+  (func (export "is_null-funcref") (param $$i i32) (result i32)
+    (ref.is_null (call $$f3 (local.get $$i)))
+  )
+)`);
+
+// ./test/core/table_set.wast:29
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:30
+assert_return(() => invoke($0, `set-externref`, [0, externref(1)]), []);
+
+// ./test/core/table_set.wast:31
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', externref(1))]);
+
+// ./test/core/table_set.wast:32
+assert_return(() => invoke($0, `set-externref`, [0, null]), []);
+
+// ./test/core/table_set.wast:33
+assert_return(() => invoke($0, `get-externref`, [0]), [value('externref', null)]);
+
+// ./test/core/table_set.wast:35
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:36
+assert_return(() => invoke($0, `set-funcref-from`, [0, 1]), []);
+
+// ./test/core/table_set.wast:37
+assert_return(() => invoke($0, `is_null-funcref`, [0]), [value("i32", 0)]);
+
+// ./test/core/table_set.wast:38
+assert_return(() => invoke($0, `set-funcref`, [0, null]), []);
+
+// ./test/core/table_set.wast:39
+assert_return(() => invoke($0, `get-funcref`, [0]), [value('anyfunc', null)]);
+
+// ./test/core/table_set.wast:41
+assert_trap(() => invoke($0, `set-externref`, [2, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:42
+assert_trap(() => invoke($0, `set-funcref`, [3, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:43
+assert_trap(() => invoke($0, `set-externref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:44
+assert_trap(() => invoke($0, `set-funcref`, [-1, null]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:46
+assert_trap(() => invoke($0, `set-externref`, [2, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:47
+assert_trap(() => invoke($0, `set-funcref-from`, [3, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:48
+assert_trap(() => invoke($0, `set-externref`, [-1, externref(0)]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:49
+assert_trap(() => invoke($0, `set-funcref-from`, [-1, 1]), `out of bounds table access`);
+
+// ./test/core/table_set.wast:54
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-value-empty-vs-i32-externref
+      (table.set $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:63
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-index-empty-vs-i32
+      (table.set $$t (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:72
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-value-empty-vs-externref
+      (table.set $$t (i32.const 1))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:81
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-size-f32-vs-i32
+      (table.set $$t (f32.const 1) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:90
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 funcref)
+    (func $$type-value-externref-vs-funcref (param $$r externref)
+      (table.set $$t (i32.const 1) (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:100
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t1 1 externref)
+    (table $$t2 1 funcref)
+    (func $$type-value-externref-vs-funcref-multi (param $$r externref)
+      (table.set $$t2 (i32.const 0) (local.get $$r))
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_set.wast:111
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 10 externref)
+    (func $$type-result-empty-vs-num (result i32)
+      (table.set $$t (i32.const 0) (ref.null extern))
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/table_size.wast.js b/js/src/jit-test/tests/wasm/spec/spec/table_size.wast.js
new file mode 100644
index 0000000000..a12edf0363
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/table_size.wast.js
@@ -0,0 +1,172 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/table_size.wast
+
+// ./test/core/table_size.wast:1
+let $0 = instantiate(`(module
+  (table $$t0 0 externref)
+  (table $$t1 1 externref)
+  (table $$t2 0 2 externref)
+  (table $$t3 3 8 externref)
+
+  (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))
+
+  (func (export "grow-t0") (param $$sz i32)
+    (drop (table.grow $$t0 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t1") (param $$sz i32)
+    (drop (table.grow $$t1 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t2") (param $$sz i32)
+    (drop (table.grow $$t2 (ref.null extern) (local.get $$sz)))
+  )
+  (func (export "grow-t3") (param $$sz i32)
+    (drop (table.grow $$t3 (ref.null extern) (local.get $$sz)))
+  )
+)`);
+
+// ./test/core/table_size.wast:26
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:27
+assert_return(() => invoke($0, `grow-t0`, [1]), []);
+
+// ./test/core/table_size.wast:28
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:29
+assert_return(() => invoke($0, `grow-t0`, [4]), []);
+
+// ./test/core/table_size.wast:30
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:31
+assert_return(() => invoke($0, `grow-t0`, [0]), []);
+
+// ./test/core/table_size.wast:32
+assert_return(() => invoke($0, `size-t0`, []), [value("i32", 5)]);
+
+// ./test/core/table_size.wast:34
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:35
+assert_return(() => invoke($0, `grow-t1`, [1]), []);
+
+// ./test/core/table_size.wast:36
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:37
+assert_return(() => invoke($0, `grow-t1`, [4]), []);
+
+// ./test/core/table_size.wast:38
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:39
+assert_return(() => invoke($0, `grow-t1`, [0]), []);
+
+// ./test/core/table_size.wast:40
+assert_return(() => invoke($0, `size-t1`, []), [value("i32", 6)]);
+
+// ./test/core/table_size.wast:42
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:43
+assert_return(() => invoke($0, `grow-t2`, [3]), []);
+
+// ./test/core/table_size.wast:44
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 0)]);
+
+// ./test/core/table_size.wast:45
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:46
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:47
+assert_return(() => invoke($0, `grow-t2`, [0]), []);
+
+// ./test/core/table_size.wast:48
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:49
+assert_return(() => invoke($0, `grow-t2`, [4]), []);
+
+// ./test/core/table_size.wast:50
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 1)]);
+
+// ./test/core/table_size.wast:51
+assert_return(() => invoke($0, `grow-t2`, [1]), []);
+
+// ./test/core/table_size.wast:52
+assert_return(() => invoke($0, `size-t2`, []), [value("i32", 2)]);
+
+// ./test/core/table_size.wast:54
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 3)]);
+
+// ./test/core/table_size.wast:55
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:56
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 4)]);
+
+// ./test/core/table_size.wast:57
+assert_return(() => invoke($0, `grow-t3`, [3]), []);
+
+// ./test/core/table_size.wast:58
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:59
+assert_return(() => invoke($0, `grow-t3`, [0]), []);
+
+// ./test/core/table_size.wast:60
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:61
+assert_return(() => invoke($0, `grow-t3`, [2]), []);
+
+// ./test/core/table_size.wast:62
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 7)]);
+
+// ./test/core/table_size.wast:63
+assert_return(() => invoke($0, `grow-t3`, [1]), []);
+
+// ./test/core/table_size.wast:64
+assert_return(() => invoke($0, `size-t3`, []), [value("i32", 8)]);
+
+// ./test/core/table_size.wast:69
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-empty
+      (table.size $$t)
+    )
+  )`),
+  `type mismatch`,
+);
+
+// ./test/core/table_size.wast:78
+assert_invalid(
+  () => instantiate(`(module
+    (table $$t 1 externref)
+    (func $$type-result-i32-vs-f32 (result f32)
+      (table.size $$t)
+    )
+  )`),
+  `type mismatch`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/token.wast.js b/js/src/jit-test/tests/wasm/spec/spec/token.wast.js
new file mode 100644
index 0000000000..0856848c1e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/token.wast.js
@@ -0,0 +1,22 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/token.wast
+
+// ./test/core/token.wast:3
+assert_malformed(() => instantiate(`(func (drop (i32.const0))) `), `unknown operator`);
+
+// ./test/core/token.wast:7
+assert_malformed(() => instantiate(`(func br 0drop) `), `unknown operator`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/tokens.wast.js b/js/src/jit-test/tests/wasm/spec/spec/tokens.wast.js
new file mode 100644
index 0000000000..e7b653f77e
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/tokens.wast.js
@@ -0,0 +1,283 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/tokens.wast
+
+// ./test/core/tokens.wast:3
+let $0 = instantiate(`(module
+  (func(nop))
+)`);
+
+// ./test/core/tokens.wast:6
+let $1 = instantiate(`(module
+  (func (nop)nop)
+)`);
+
+// ./test/core/tokens.wast:9
+let $2 = instantiate(`(module
+  (func nop(nop))
+)`);
+
+// ./test/core/tokens.wast:12
+let $3 = instantiate(`(module
+  (func(nop)(nop))
+)`);
+
+// ./test/core/tokens.wast:15
+let $4 = instantiate(`(module
+  (func $$f(nop))
+)`);
+
+// ./test/core/tokens.wast:18
+let $5 = instantiate(`(module
+  (func br 0(nop))
+)`);
+
+// ./test/core/tokens.wast:21
+let $6 = instantiate(`(module
+  (table 1 funcref)
+  (func)
+  (elem (i32.const 0)0)
+)`);
+
+// ./test/core/tokens.wast:26
+let $7 = instantiate(`(module
+  (table 1 funcref)
+  (func $$f)
+  (elem (i32.const 0)$$f)
+)`);
+
+// ./test/core/tokens.wast:31
+let $8 = instantiate(`(module
+  (memory 1)
+  (data (i32.const 0)"a")
+)`);
+
+// ./test/core/tokens.wast:35
+let $9 = instantiate(`(module
+  (import "spectest" "print"(func))
+)`);
+
+// ./test/core/tokens.wast:42
+let $10 = instantiate(`(module
+  (func;;bla
+  )
+)`);
+
+// ./test/core/tokens.wast:46
+let $11 = instantiate(`(module
+  (func (nop);;bla
+  )
+)`);
+
+// ./test/core/tokens.wast:50
+let $12 = instantiate(`(module
+  (func nop;;bla
+  )
+)`);
+
+// ./test/core/tokens.wast:54
+let $13 = instantiate(`(module
+  (func $$f;;bla
+  )
+)`);
+
+// ./test/core/tokens.wast:58
+let $14 = instantiate(`(module
+  (func br 0;;bla
+  )
+)`);
+
+// ./test/core/tokens.wast:62
+let $15 = instantiate(`(module
+  (data "a";;bla
+  )
+)`);
+
+// ./test/core/tokens.wast:70
+let $16 = instantiate(`(module
+  (func (block $$l (i32.const 0) (br_table 0 $$l)))
+)`);
+
+// ./test/core/tokens.wast:73
+assert_malformed(
+  () => instantiate(`(func (block $$l (i32.const 0) (br_table 0$$l))) `),
+  `unknown operator`,
+);
+
+// ./test/core/tokens.wast:80
+let $17 = instantiate(`(module
+  (func (block $$l (i32.const 0) (br_table $$l 0)))
+)`);
+
+// ./test/core/tokens.wast:83
+assert_malformed(
+  () => instantiate(`(func (block $$l (i32.const 0) (br_table $$l0))) `),
+  `unknown label`,
+);
+
+// ./test/core/tokens.wast:90
+let $18 = instantiate(`(module
+  (func (block $$l (i32.const 0) (br_table $$l $$l)))
+)`);
+
+// ./test/core/tokens.wast:93
+assert_malformed(
+  () => instantiate(`(func (block $$l (i32.const 0) (br_table $$l$$l))) `),
+  `unknown label`,
+);
+
+// ./test/core/tokens.wast:100
+let $19 = instantiate(`(module
+  (func (block $$l0 (i32.const 0) (br_table $$l0)))
+)`);
+
+// ./test/core/tokens.wast:103
+let $20 = instantiate(`(module
+  (func (block $$l$$l (i32.const 0) (br_table $$l$$l)))
+)`);
+
+// ./test/core/tokens.wast:110
+let $21 = instantiate(`(module
+  (data "a")
+)`);
+
+// ./test/core/tokens.wast:113
+assert_malformed(() => instantiate(`(data"a") `), `unknown operator`);
+
+// ./test/core/tokens.wast:120
+let $22 = instantiate(`(module
+  (data $$l "a")
+)`);
+
+// ./test/core/tokens.wast:123
+assert_malformed(() => instantiate(`(data $$l"a") `), `unknown operator`);
+
+// ./test/core/tokens.wast:130
+let $23 = instantiate(`(module
+  (data $$l " a")
+)`);
+
+// ./test/core/tokens.wast:133
+assert_malformed(() => instantiate(`(data $$l" a") `), `unknown operator`);
+
+// ./test/core/tokens.wast:140
+let $24 = instantiate(`(module
+  (data $$l "a ")
+)`);
+
+// ./test/core/tokens.wast:143
+assert_malformed(() => instantiate(`(data $$l"a ") `), `unknown operator`);
+
+// ./test/core/tokens.wast:150
+let $25 = instantiate(`(module
+  (data $$l "a " "b")
+)`);
+
+// ./test/core/tokens.wast:153
+assert_malformed(() => instantiate(`(data $$l"a ""b") `), `unknown operator`);
+
+// ./test/core/tokens.wast:160
+let $26 = instantiate(`(module
+  (data $$l "\u{f61a}\u{f4a9}")
+)`);
+
+// ./test/core/tokens.wast:163
+assert_malformed(() => instantiate(`(data $$l"\u{f61a}\u{f4a9}") `), `unknown operator`);
+
+// ./test/core/tokens.wast:170
+let $27 = instantiate(`(module
+  (data $$l " \u{f61a}\u{f4a9}")
+)`);
+
+// ./test/core/tokens.wast:173
+assert_malformed(() => instantiate(`(data $$l" \u{f61a}\u{f4a9}") `), `unknown operator`);
+
+// ./test/core/tokens.wast:180
+let $28 = instantiate(`(module
+  (data $$l "\u{f61a}\u{f4a9} ")
+)`);
+
+// ./test/core/tokens.wast:183
+assert_malformed(() => instantiate(`(data $$l"\u{f61a}\u{f4a9} ") `), `unknown operator`);
+
+// ./test/core/tokens.wast:190
+let $29 = instantiate(`(module
+  (data "a" "b")
+)`);
+
+// ./test/core/tokens.wast:193
+assert_malformed(() => instantiate(`(data "a""b") `), `unknown operator`);
+
+// ./test/core/tokens.wast:200
+let $30 = instantiate(`(module
+  (data "a" " b")
+)`);
+
+// ./test/core/tokens.wast:203
+assert_malformed(() => instantiate(`(data "a"" b") `), `unknown operator`);
+
+// ./test/core/tokens.wast:210
+let $31 = instantiate(`(module
+  (data "a " "b")
+)`);
+
+// ./test/core/tokens.wast:213
+assert_malformed(() => instantiate(`(data "a ""b") `), `unknown operator`);
+
+// ./test/core/tokens.wast:220
+let $32 = instantiate(`(module
+  (data "\u{f61a}\u{f4a9}" "\u{f61a}\u{f4a9}")
+)`);
+
+// ./test/core/tokens.wast:223
+assert_malformed(
+  () => instantiate(`(data "\u{f61a}\u{f4a9}""\u{f61a}\u{f4a9}") `),
+  `unknown operator`,
+);
+
+// ./test/core/tokens.wast:230
+let $33 = instantiate(`(module
+  (data "\u{f61a}\u{f4a9}" " \u{f61a}\u{f4a9}")
+)`);
+
+// ./test/core/tokens.wast:233
+assert_malformed(
+  () => instantiate(`(data "\u{f61a}\u{f4a9}"" \u{f61a}\u{f4a9}") `),
+  `unknown operator`,
+);
+
+// ./test/core/tokens.wast:240
+let $34 = instantiate(`(module
+  (data "\u{f61a}\u{f4a9} " "\u{f61a}\u{f4a9}")
+)`);
+
+// ./test/core/tokens.wast:243
+assert_malformed(
+  () => instantiate(`(data "\u{f61a}\u{f4a9} ""\u{f61a}\u{f4a9}") `),
+  `unknown operator`,
+);
+
+// ./test/core/tokens.wast:251
+assert_malformed(() => instantiate(`(func "a"x) `), `unknown operator`);
+
+// ./test/core/tokens.wast:257
+assert_malformed(() => instantiate(`(func "a"0) `), `unknown operator`);
+
+// ./test/core/tokens.wast:263
+assert_malformed(() => instantiate(`(func 0"a") `), `unknown operator`);
+
+// ./test/core/tokens.wast:269
+assert_malformed(() => instantiate(`(func "a"$$x) `), `unknown operator`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/traps.wast.js b/js/src/jit-test/tests/wasm/spec/spec/traps.wast.js
new file mode 100644
index 0000000000..61fc4dcacc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/traps.wast.js
@@ -0,0 +1,200 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/traps.wast
+
+// ./test/core/traps.wast:5
+let $0 = instantiate(`(module
+  (func (export "no_dce.i32.div_s") (param $$x i32) (param $$y i32)
+    (drop (i32.div_s (local.get $$x) (local.get $$y))))
+  (func (export "no_dce.i32.div_u") (param $$x i32) (param $$y i32)
+    (drop (i32.div_u (local.get $$x) (local.get $$y))))
+  (func (export "no_dce.i64.div_s") (param $$x i64) (param $$y i64)
+    (drop (i64.div_s (local.get $$x) (local.get $$y))))
+  (func (export "no_dce.i64.div_u") (param $$x i64) (param $$y i64)
+    (drop (i64.div_u (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/traps.wast:16
+assert_trap(() => invoke($0, `no_dce.i32.div_s`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/traps.wast:17
+assert_trap(() => invoke($0, `no_dce.i32.div_u`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/traps.wast:18
+assert_trap(() => invoke($0, `no_dce.i64.div_s`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/traps.wast:19
+assert_trap(() => invoke($0, `no_dce.i64.div_u`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/traps.wast:20
+assert_trap(() => invoke($0, `no_dce.i32.div_s`, [-2147483648, -1]), `integer overflow`);
+
+// ./test/core/traps.wast:21
+assert_trap(() => invoke($0, `no_dce.i64.div_s`, [-9223372036854775808n, -1n]), `integer overflow`);
+
+// ./test/core/traps.wast:23
+let $1 = instantiate(`(module
+  (func (export "no_dce.i32.rem_s") (param $$x i32) (param $$y i32)
+    (drop (i32.rem_s (local.get $$x) (local.get $$y))))
+  (func (export "no_dce.i32.rem_u") (param $$x i32) (param $$y i32)
+    (drop (i32.rem_u (local.get $$x) (local.get $$y))))
+  (func (export "no_dce.i64.rem_s") (param $$x i64) (param $$y i64)
+    (drop (i64.rem_s (local.get $$x) (local.get $$y))))
+  (func (export "no_dce.i64.rem_u") (param $$x i64) (param $$y i64)
+    (drop (i64.rem_u (local.get $$x) (local.get $$y))))
+)`);
+
+// ./test/core/traps.wast:34
+assert_trap(() => invoke($1, `no_dce.i32.rem_s`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/traps.wast:35
+assert_trap(() => invoke($1, `no_dce.i32.rem_u`, [1, 0]), `integer divide by zero`);
+
+// ./test/core/traps.wast:36
+assert_trap(() => invoke($1, `no_dce.i64.rem_s`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/traps.wast:37
+assert_trap(() => invoke($1, `no_dce.i64.rem_u`, [1n, 0n]), `integer divide by zero`);
+
+// ./test/core/traps.wast:39
+let $2 = instantiate(`(module
+  (func (export "no_dce.i32.trunc_f32_s") (param $$x f32) (drop (i32.trunc_f32_s (local.get $$x))))
+  (func (export "no_dce.i32.trunc_f32_u") (param $$x f32) (drop (i32.trunc_f32_u (local.get $$x))))
+  (func (export "no_dce.i32.trunc_f64_s") (param $$x f64) (drop (i32.trunc_f64_s (local.get $$x))))
+  (func (export "no_dce.i32.trunc_f64_u") (param $$x f64) (drop (i32.trunc_f64_u (local.get $$x))))
+  (func (export "no_dce.i64.trunc_f32_s") (param $$x f32) (drop (i64.trunc_f32_s (local.get $$x))))
+  (func (export "no_dce.i64.trunc_f32_u") (param $$x f32) (drop (i64.trunc_f32_u (local.get $$x))))
+  (func (export "no_dce.i64.trunc_f64_s") (param $$x f64) (drop (i64.trunc_f64_s (local.get $$x))))
+  (func (export "no_dce.i64.trunc_f64_u") (param $$x f64) (drop (i64.trunc_f64_u (local.get $$x))))
+)`);
+
+// ./test/core/traps.wast:50
+assert_trap(
+  () => invoke($2, `no_dce.i32.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:51
+assert_trap(
+  () => invoke($2, `no_dce.i32.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:52
+assert_trap(
+  () => invoke($2, `no_dce.i32.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:53
+assert_trap(
+  () => invoke($2, `no_dce.i32.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:54
+assert_trap(
+  () => invoke($2, `no_dce.i64.trunc_f32_s`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:55
+assert_trap(
+  () => invoke($2, `no_dce.i64.trunc_f32_u`, [bytes("f32", [0x0, 0x0, 0xc0, 0x7f])]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:56
+assert_trap(
+  () => invoke($2, `no_dce.i64.trunc_f64_s`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:57
+assert_trap(
+  () => invoke($2, `no_dce.i64.trunc_f64_u`, [
+    bytes("f64", [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xf8, 0x7f]),
+  ]),
+  `invalid conversion to integer`,
+);
+
+// ./test/core/traps.wast:59
+let $3 = instantiate(`(module
+    (memory 1)
+
+    (func (export "no_dce.i32.load") (param $$i i32) (drop (i32.load (local.get $$i))))
+    (func (export "no_dce.i32.load16_s") (param $$i i32) (drop (i32.load16_s (local.get $$i))))
+    (func (export "no_dce.i32.load16_u") (param $$i i32) (drop (i32.load16_u (local.get $$i))))
+    (func (export "no_dce.i32.load8_s") (param $$i i32) (drop (i32.load8_s (local.get $$i))))
+    (func (export "no_dce.i32.load8_u") (param $$i i32) (drop (i32.load8_u (local.get $$i))))
+    (func (export "no_dce.i64.load") (param $$i i32) (drop (i64.load (local.get $$i))))
+    (func (export "no_dce.i64.load32_s") (param $$i i32) (drop (i64.load32_s (local.get $$i))))
+    (func (export "no_dce.i64.load32_u") (param $$i i32) (drop (i64.load32_u (local.get $$i))))
+    (func (export "no_dce.i64.load16_s") (param $$i i32) (drop (i64.load16_s (local.get $$i))))
+    (func (export "no_dce.i64.load16_u") (param $$i i32) (drop (i64.load16_u (local.get $$i))))
+    (func (export "no_dce.i64.load8_s") (param $$i i32) (drop (i64.load8_s (local.get $$i))))
+    (func (export "no_dce.i64.load8_u") (param $$i i32) (drop (i64.load8_u (local.get $$i))))
+    (func (export "no_dce.f32.load") (param $$i i32) (drop (f32.load (local.get $$i))))
+    (func (export "no_dce.f64.load") (param $$i i32) (drop (f64.load (local.get $$i))))
+)`);
+
+// ./test/core/traps.wast:78
+assert_trap(() => invoke($3, `no_dce.i32.load`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:79
+assert_trap(() => invoke($3, `no_dce.i32.load16_s`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:80
+assert_trap(() => invoke($3, `no_dce.i32.load16_u`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:81
+assert_trap(() => invoke($3, `no_dce.i32.load8_s`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:82
+assert_trap(() => invoke($3, `no_dce.i32.load8_u`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:83
+assert_trap(() => invoke($3, `no_dce.i64.load`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:84
+assert_trap(() => invoke($3, `no_dce.i64.load32_s`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:85
+assert_trap(() => invoke($3, `no_dce.i64.load32_u`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:86
+assert_trap(() => invoke($3, `no_dce.i64.load16_s`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:87
+assert_trap(() => invoke($3, `no_dce.i64.load16_u`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:88
+assert_trap(() => invoke($3, `no_dce.i64.load8_s`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:89
+assert_trap(() => invoke($3, `no_dce.i64.load8_u`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:90
+assert_trap(() => invoke($3, `no_dce.f32.load`, [65536]), `out of bounds memory access`);
+
+// ./test/core/traps.wast:91
+assert_trap(() => invoke($3, `no_dce.f64.load`, [65536]), `out of bounds memory access`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/type.wast.js b/js/src/jit-test/tests/wasm/spec/spec/type.wast.js
new file mode 100644
index 0000000000..f4d3ede687
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/type.wast.js
@@ -0,0 +1,66 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/type.wast
+
+// ./test/core/type.wast:3
+let $0 = instantiate(`(module
+  (type (func))
+  (type $$t (func))
+
+  (type (func (param i32)))
+  (type (func (param $$x i32)))
+  (type (func (result i32)))
+  (type (func (param i32) (result i32)))
+  (type (func (param $$x i32) (result i32)))
+
+  (type (func (param f32 f64)))
+  (type (func (result i64 f32)))
+  (type (func (param i32 i64) (result f32 f64)))
+
+  (type (func (param f32) (param f64)))
+  (type (func (param $$x f32) (param f64)))
+  (type (func (param f32) (param $$y f64)))
+  (type (func (param $$x f32) (param $$y f64)))
+  (type (func (result i64) (result f32)))
+  (type (func (param i32) (param i64) (result f32) (result f64)))
+  (type (func (param $$x i32) (param $$y i64) (result f32) (result f64)))
+
+  (type (func (param f32 f64) (param $$x i32) (param f64 i32 i32)))
+  (type (func (result i64 i64 f32) (result f32 i32)))
+  (type
+    (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32))
+  )
+
+  (type (func (param) (param $$x f32) (param) (param) (param f64 i32) (param)))
+  (type
+    (func (result) (result) (result i64 i64) (result) (result f32) (result))
+  )
+  (type
+    (func
+      (param i32 i32) (param i64 i32) (param) (param $$x i32) (param)
+      (result) (result f32 f64) (result f64 i32) (result)
+    )
+  )
+)`);
+
+// ./test/core/type.wast:43
+assert_malformed(
+  () => instantiate(`(type (func (result i32) (param i32))) `),
+  `unexpected token`,
+);
+
+// ./test/core/type.wast:47
+assert_malformed(() => instantiate(`(type (func (result $$x i32))) `), `unexpected token`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/unreachable.wast.js b/js/src/jit-test/tests/wasm/spec/spec/unreachable.wast.js
new file mode 100644
index 0000000000..70eafb7db3
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/unreachable.wast.js
@@ -0,0 +1,424 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/unreachable.wast
+
+// ./test/core/unreachable.wast:3
+let $0 = instantiate(`(module
+  ;; Auxiliary definitions
+  (func $$dummy)
+  (func $$dummy3 (param i32 i32 i32))
+
+  (func (export "type-i32") (result i32) (unreachable))
+  (func (export "type-i64") (result i32) (unreachable))
+  (func (export "type-f32") (result f64) (unreachable))
+  (func (export "type-f64") (result f64) (unreachable))
+
+  (func (export "as-func-first") (result i32)
+    (unreachable) (i32.const -1)
+  )
+  (func (export "as-func-mid") (result i32)
+    (call $$dummy) (unreachable) (i32.const -1)
+  )
+  (func (export "as-func-last")
+    (call $$dummy) (unreachable)
+  )
+  (func (export "as-func-value") (result i32)
+    (call $$dummy) (unreachable)
+  )
+
+  (func (export "as-block-first") (result i32)
+    (block (result i32) (unreachable) (i32.const 2))
+  )
+  (func (export "as-block-mid") (result i32)
+    (block (result i32) (call $$dummy) (unreachable) (i32.const 2))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $$dummy) (unreachable))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $$dummy) (unreachable))
+  )
+  (func (export "as-block-broke") (result i32)
+    (block (result i32) (call $$dummy) (br 0 (i32.const 1)) (unreachable))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (unreachable) (i32.const 2))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $$dummy) (unreachable) (i32.const 2))
+  )
+  (func (export "as-loop-last")
+    (loop (nop) (call $$dummy) (unreachable))
+  )
+  (func (export "as-loop-broke") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $$dummy) (br 1 (i32.const 1)) (unreachable))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (unreachable)))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (unreachable)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (unreachable)))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-2") (result i32)
+    (block (result i32)
+      (block (result i32) (br_table 0 1 (unreachable) (i32.const 1)))
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-and-index") (result i32)
+    (block (result i32) (br_table 0 0 (unreachable)) (i32.const 8))
+  )
+
+  (func (export "as-return-value") (result i64)
+    (return (unreachable))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1)))
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0) (then (unreachable)) (else (local.get 1)))
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 1)) (else (unreachable)))
+  )
+  (func (export "as-if-then-no-else") (param i32 i32) (result i32)
+    (if (local.get 0) (then (unreachable))) (local.get 1)
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (unreachable) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (unreachable) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (unreachable))
+  )
+
+  (func (export "as-call-first")
+    (call $$dummy3 (unreachable) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid")
+    (call $$dummy3 (i32.const 1) (unreachable) (i32.const 3))
+  )
+  (func (export "as-call-last")
+    (call $$dummy3 (i32.const 1) (i32.const 2) (unreachable))
+  )
+
+  (type $$sig (func (param i32 i32 i32)))
+  (table funcref (elem $$dummy3))
+  (func (export "as-call_indirect-func")
+    (call_indirect (type $$sig)
+      (unreachable) (i32.const 1) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-first")
+    (call_indirect (type $$sig)
+      (i32.const 0) (unreachable) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-mid")
+    (call_indirect (type $$sig)
+      (i32.const 0) (i32.const 1) (unreachable) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-last")
+    (call_indirect (type $$sig)
+      (i32.const 0) (i32.const 1) (i32.const 2) (unreachable)
+    )
+  )
+
+  (func (export "as-local.set-value") (local f32)
+    (local.set 0 (unreachable))
+  )
+  (func (export "as-local.tee-value") (result f32) (local f32)
+    (local.tee 0 (unreachable))
+  )
+  (global $$a (mut f32) (f32.const 0))
+  (func (export "as-global.set-value") (result f32)
+    (global.set $$a (unreachable))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (f32.load (unreachable))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (i64.load8_s (unreachable))
+  )
+
+  (func (export "as-store-address")
+    (f64.store (unreachable) (f64.const 7))
+  )
+  (func (export "as-store-value")
+    (i64.store (i32.const 2) (unreachable))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (unreachable) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i64.store16 (i32.const 2) (unreachable))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (f32.neg (unreachable))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (unreachable) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i64)
+    (i64.sub (i64.const 10) (unreachable))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (unreachable))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (f64.le (unreachable) (f64.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (f32.ne (f32.const 10) (unreachable))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (i32.wrap_i64 (unreachable))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (unreachable))
+  )
+)`);
+
+// ./test/core/unreachable.wast:221
+assert_trap(() => invoke($0, `type-i32`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:222
+assert_trap(() => invoke($0, `type-i64`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:223
+assert_trap(() => invoke($0, `type-f32`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:224
+assert_trap(() => invoke($0, `type-f64`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:226
+assert_trap(() => invoke($0, `as-func-first`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:227
+assert_trap(() => invoke($0, `as-func-mid`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:228
+assert_trap(() => invoke($0, `as-func-last`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:229
+assert_trap(() => invoke($0, `as-func-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:231
+assert_trap(() => invoke($0, `as-block-first`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:232
+assert_trap(() => invoke($0, `as-block-mid`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:233
+assert_trap(() => invoke($0, `as-block-last`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:234
+assert_trap(() => invoke($0, `as-block-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:235
+assert_return(() => invoke($0, `as-block-broke`, []), [value("i32", 1)]);
+
+// ./test/core/unreachable.wast:237
+assert_trap(() => invoke($0, `as-loop-first`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:238
+assert_trap(() => invoke($0, `as-loop-mid`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:239
+assert_trap(() => invoke($0, `as-loop-last`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:240
+assert_return(() => invoke($0, `as-loop-broke`, []), [value("i32", 1)]);
+
+// ./test/core/unreachable.wast:242
+assert_trap(() => invoke($0, `as-br-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:244
+assert_trap(() => invoke($0, `as-br_if-cond`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:245
+assert_trap(() => invoke($0, `as-br_if-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:246
+assert_trap(() => invoke($0, `as-br_if-value-cond`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:248
+assert_trap(() => invoke($0, `as-br_table-index`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:249
+assert_trap(() => invoke($0, `as-br_table-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:250
+assert_trap(() => invoke($0, `as-br_table-value-2`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:251
+assert_trap(() => invoke($0, `as-br_table-value-index`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:252
+assert_trap(() => invoke($0, `as-br_table-value-and-index`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:254
+assert_trap(() => invoke($0, `as-return-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:256
+assert_trap(() => invoke($0, `as-if-cond`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:257
+assert_trap(() => invoke($0, `as-if-then`, [1, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:258
+assert_return(() => invoke($0, `as-if-then`, [0, 6]), [value("i32", 6)]);
+
+// ./test/core/unreachable.wast:259
+assert_trap(() => invoke($0, `as-if-else`, [0, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:260
+assert_return(() => invoke($0, `as-if-else`, [1, 6]), [value("i32", 6)]);
+
+// ./test/core/unreachable.wast:261
+assert_trap(() => invoke($0, `as-if-then-no-else`, [1, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:262
+assert_return(() => invoke($0, `as-if-then-no-else`, [0, 6]), [value("i32", 6)]);
+
+// ./test/core/unreachable.wast:264
+assert_trap(() => invoke($0, `as-select-first`, [0, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:265
+assert_trap(() => invoke($0, `as-select-first`, [1, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:266
+assert_trap(() => invoke($0, `as-select-second`, [0, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:267
+assert_trap(() => invoke($0, `as-select-second`, [1, 6]), `unreachable`);
+
+// ./test/core/unreachable.wast:268
+assert_trap(() => invoke($0, `as-select-cond`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:270
+assert_trap(() => invoke($0, `as-call-first`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:271
+assert_trap(() => invoke($0, `as-call-mid`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:272
+assert_trap(() => invoke($0, `as-call-last`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:274
+assert_trap(() => invoke($0, `as-call_indirect-func`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:275
+assert_trap(() => invoke($0, `as-call_indirect-first`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:276
+assert_trap(() => invoke($0, `as-call_indirect-mid`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:277
+assert_trap(() => invoke($0, `as-call_indirect-last`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:279
+assert_trap(() => invoke($0, `as-local.set-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:280
+assert_trap(() => invoke($0, `as-local.tee-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:281
+assert_trap(() => invoke($0, `as-global.set-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:283
+assert_trap(() => invoke($0, `as-load-address`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:284
+assert_trap(() => invoke($0, `as-loadN-address`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:286
+assert_trap(() => invoke($0, `as-store-address`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:287
+assert_trap(() => invoke($0, `as-store-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:288
+assert_trap(() => invoke($0, `as-storeN-address`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:289
+assert_trap(() => invoke($0, `as-storeN-value`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:291
+assert_trap(() => invoke($0, `as-unary-operand`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:293
+assert_trap(() => invoke($0, `as-binary-left`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:294
+assert_trap(() => invoke($0, `as-binary-right`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:296
+assert_trap(() => invoke($0, `as-test-operand`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:298
+assert_trap(() => invoke($0, `as-compare-left`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:299
+assert_trap(() => invoke($0, `as-compare-right`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:301
+assert_trap(() => invoke($0, `as-convert-operand`, []), `unreachable`);
+
+// ./test/core/unreachable.wast:303
+assert_trap(() => invoke($0, `as-memory.grow-size`, []), `unreachable`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/unreached-valid.wast.js b/js/src/jit-test/tests/wasm/spec/spec/unreached-valid.wast.js
new file mode 100644
index 0000000000..aece5191dc
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/unreached-valid.wast.js
@@ -0,0 +1,88 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/unreached-valid.wast
+
+// ./test/core/unreached-valid.wast:1
+let $0 = instantiate(`(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)
+  )
+)`);
+
+// ./test/core/unreached-valid.wast:42
+assert_trap(() => invoke($0, `select-trap-left`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:43
+assert_trap(() => invoke($0, `select-trap-left`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:44
+assert_trap(() => invoke($0, `select-trap-right`, [1]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:45
+assert_trap(() => invoke($0, `select-trap-right`, [0]), `unreachable`);
+
+// ./test/core/unreached-valid.wast:49
+let $1 = instantiate(`(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)
+  )
+)`);
+
+// ./test/core/unreached-valid.wast:63
+assert_trap(() => invoke($1, `meet-bottom`, []), `unreachable`);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/unwind.wast.js b/js/src/jit-test/tests/wasm/spec/spec/unwind.wast.js
new file mode 100644
index 0000000000..5567d3473d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/unwind.wast.js
@@ -0,0 +1,373 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/unwind.wast
+
+// ./test/core/unwind.wast:3
+let $0 = instantiate(`(module
+  (func (export "func-unwind-by-unreachable")
+    (i32.const 3) (i64.const 1) (unreachable)
+  )
+  (func (export "func-unwind-by-br")
+    (i32.const 3) (i64.const 1) (br 0)
+  )
+  (func (export "func-unwind-by-br-value") (result i32)
+    (i32.const 3) (i64.const 1) (br 0 (i32.const 9))
+  )
+  (func (export "func-unwind-by-br_if")
+    (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))
+  )
+  (func (export "func-unwind-by-br_if-value") (result i32)
+    (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1))))
+  )
+  (func (export "func-unwind-by-br_table")
+    (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))
+  )
+  (func (export "func-unwind-by-br_table-value") (result i32)
+    (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
+  )
+  (func (export "func-unwind-by-return") (result i32)
+    (i32.const 3) (i64.const 1) (return (i32.const 9))
+  )
+
+  (func (export "block-unwind-by-unreachable")
+    (block (i32.const 3) (i64.const 1) (unreachable))
+  )
+  (func (export "block-unwind-by-br") (result i32)
+    (block (i32.const 3) (i64.const 1) (br 0)) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br-value") (result i32)
+    (block (result i32) (i32.const 3) (i64.const 1) (br 0 (i32.const 9)))
+  )
+  (func (export "block-unwind-by-br_if") (result i32)
+    (block (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br_if-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1))))
+    )
+  )
+  (func (export "block-unwind-by-br_table") (result i32)
+    (block (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br_table-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
+    )
+  )
+  (func (export "block-unwind-by-return") (result i32)
+    (block (result i32) (i32.const 3) (i64.const 1) (return (i32.const 9)))
+  )
+
+  (func (export "block-nested-unwind-by-unreachable") (result i32)
+    (block (result i32) (i32.const 3) (block (i64.const 1) (unreachable)))
+  )
+  (func (export "block-nested-unwind-by-br") (result i32)
+    (block (i32.const 3) (block (i64.const 1) (br 1)) (drop)) (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9)))
+    )
+  )
+  (func (export "block-nested-unwind-by-br_if") (result i32)
+    (block (i32.const 3) (block (i64.const 1) (drop (br_if 1 (i32.const 1)))) (drop)) (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br_if-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (drop (drop (br_if 1 (i32.const 9) (i32.const 1)))))
+    )
+  )
+  (func (export "block-nested-unwind-by-br_table") (result i32)
+    (block
+      (i32.const 3) (block (i64.const 1) (br_table 1 (i32.const 1)))
+      (drop)
+    )
+    (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br_table-value") (result i32)
+    (block (result i32)
+      (i32.const 3)
+      (block (i64.const 1) (br_table 1 (i32.const 9) (i32.const 1)))
+    )
+  )
+  (func (export "block-nested-unwind-by-return") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (return (i32.const 9)))
+    )
+  )
+
+  (func (export "unary-after-unreachable") (result i32)
+    (f32.const 0) (unreachable) (i64.eqz)
+  )
+  (func (export "unary-after-br") (result i32)
+    (block (result i32) (f32.const 0) (br 0 (i32.const 9)) (i64.eqz))
+  )
+  (func (export "unary-after-br_if") (result i32)
+    (block (result i32)
+      (i64.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1))) (i64.eqz)
+    )
+  )
+  (func (export "unary-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) (i64.eqz)
+    )
+  )
+  (func (export "unary-after-return") (result i32)
+    (f32.const 0) (return (i32.const 9)) (i64.eqz)
+  )
+
+  (func (export "binary-after-unreachable") (result i32)
+    (f32.const 0) (f64.const 1) (unreachable) (i64.eq)
+  )
+  (func (export "binary-after-br") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq)
+    )
+  )
+  (func (export "binary-after-br_if") (result i32)
+    (block (result i32)
+      (i64.const 0) (i64.const 1) (drop (br_if 0 (i32.const 9) (i32.const 1)))
+      (i64.eq)
+    )
+  )
+  (func (export "binary-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
+      (i64.eq)
+    )
+  )
+  (func (export "binary-after-return") (result i32)
+    (f32.const 0) (f64.const 1) (return (i32.const 9)) (i64.eq)
+  )
+
+  (func (export "select-after-unreachable") (result i32)
+    (f32.const 0) (f64.const 1) (i64.const 0) (unreachable) (select)
+  )
+  (func (export "select-after-br") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (i64.const 0) (br 0 (i32.const 9)) (select)
+    )
+  )
+  (func (export "select-after-br_if") (result i32)
+    (block (result i32)
+      (i32.const 0) (i32.const 1) (i32.const 0)
+      (drop (br_if 0 (i32.const 9) (i32.const 1)))
+      (select)
+    )
+  )
+  (func (export "select-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (i64.const 0)
+      (br_table 0 (i32.const 9) (i32.const 0))
+      (select)
+    )
+  )
+  (func (export "select-after-return") (result i32)
+    (f32.const 0) (f64.const 1) (i64.const 1) (return (i32.const 9)) (select)
+  )
+
+  (func (export "block-value-after-unreachable") (result i32)
+    (block (result i32) (f32.const 0) (unreachable))
+  )
+  (func (export "block-value-after-br") (result i32)
+    (block (result i32) (f32.const 0) (br 0 (i32.const 9)))
+  )
+  (func (export "block-value-after-br_if") (result i32)
+    (block (result i32)
+      (i32.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1)))
+    )
+  )
+  (func (export "block-value-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0))
+    )
+  )
+  (func (export "block-value-after-return") (result i32)
+    (block (result i32) (f32.const 0) (return (i32.const 9)))
+  )
+
+  (func (export "loop-value-after-unreachable") (result i32)
+    (loop (result i32) (f32.const 0) (unreachable))
+  )
+  (func (export "loop-value-after-br") (result i32)
+    (block (result i32) (loop (result i32) (f32.const 0) (br 1 (i32.const 9))))
+  )
+  (func (export "loop-value-after-br_if") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (i32.const 0) (drop (br_if 1 (i32.const 9) (i32.const 1)))
+      )
+    )
+  )
+
+  (func (export "loop-value-after-br_table") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0))
+      )
+    )
+  )
+  (func (export "loop-value-after-return") (result i32)
+    (loop (result i32) (f32.const 0) (return (i32.const 9)))
+  )
+)`);
+
+// ./test/core/unwind.wast:212
+assert_trap(() => invoke($0, `func-unwind-by-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:213
+assert_return(() => invoke($0, `func-unwind-by-br`, []), []);
+
+// ./test/core/unwind.wast:214
+assert_return(() => invoke($0, `func-unwind-by-br-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:215
+assert_return(() => invoke($0, `func-unwind-by-br_if`, []), []);
+
+// ./test/core/unwind.wast:216
+assert_return(() => invoke($0, `func-unwind-by-br_if-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:217
+assert_return(() => invoke($0, `func-unwind-by-br_table`, []), []);
+
+// ./test/core/unwind.wast:218
+assert_return(() => invoke($0, `func-unwind-by-br_table-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:219
+assert_return(() => invoke($0, `func-unwind-by-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:221
+assert_trap(() => invoke($0, `block-unwind-by-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:222
+assert_return(() => invoke($0, `block-unwind-by-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:223
+assert_return(() => invoke($0, `block-unwind-by-br-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:224
+assert_return(() => invoke($0, `block-unwind-by-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:225
+assert_return(() => invoke($0, `block-unwind-by-br_if-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:226
+assert_return(() => invoke($0, `block-unwind-by-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:227
+assert_return(() => invoke($0, `block-unwind-by-br_table-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:228
+assert_return(() => invoke($0, `block-unwind-by-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:230
+assert_trap(() => invoke($0, `block-nested-unwind-by-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:231
+assert_return(() => invoke($0, `block-nested-unwind-by-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:232
+assert_return(() => invoke($0, `block-nested-unwind-by-br-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:233
+assert_return(() => invoke($0, `block-nested-unwind-by-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:234
+assert_return(() => invoke($0, `block-nested-unwind-by-br_if-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:235
+assert_return(() => invoke($0, `block-nested-unwind-by-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:236
+assert_return(() => invoke($0, `block-nested-unwind-by-br_table-value`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:237
+assert_return(() => invoke($0, `block-nested-unwind-by-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:239
+assert_trap(() => invoke($0, `unary-after-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:240
+assert_return(() => invoke($0, `unary-after-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:241
+assert_return(() => invoke($0, `unary-after-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:242
+assert_return(() => invoke($0, `unary-after-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:243
+assert_return(() => invoke($0, `unary-after-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:245
+assert_trap(() => invoke($0, `binary-after-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:246
+assert_return(() => invoke($0, `binary-after-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:247
+assert_return(() => invoke($0, `binary-after-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:248
+assert_return(() => invoke($0, `binary-after-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:249
+assert_return(() => invoke($0, `binary-after-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:251
+assert_trap(() => invoke($0, `select-after-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:252
+assert_return(() => invoke($0, `select-after-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:253
+assert_return(() => invoke($0, `select-after-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:254
+assert_return(() => invoke($0, `select-after-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:255
+assert_return(() => invoke($0, `select-after-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:257
+assert_trap(() => invoke($0, `block-value-after-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:258
+assert_return(() => invoke($0, `block-value-after-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:259
+assert_return(() => invoke($0, `block-value-after-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:260
+assert_return(() => invoke($0, `block-value-after-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:261
+assert_return(() => invoke($0, `block-value-after-return`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:263
+assert_trap(() => invoke($0, `loop-value-after-unreachable`, []), `unreachable`);
+
+// ./test/core/unwind.wast:264
+assert_return(() => invoke($0, `loop-value-after-br`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:265
+assert_return(() => invoke($0, `loop-value-after-br_if`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:266
+assert_return(() => invoke($0, `loop-value-after-br_table`, []), [value("i32", 9)]);
+
+// ./test/core/unwind.wast:267
+assert_return(() => invoke($0, `loop-value-after-return`, []), [value("i32", 9)]);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/utf8-import-field.wast.js b/js/src/jit-test/tests/wasm/spec/spec/utf8-import-field.wast.js
new file mode 100644
index 0000000000..658da5449f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/utf8-import-field.wast.js
@@ -0,0 +1,2656 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/utf8-import-field.wast
+
+// ./test/core/utf8-import-field.wast:6
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\80"                       ;; "\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:21
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\8f"                       ;; "\\8f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:36
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\90"                       ;; "\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:51
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\9f"                       ;; "\\9f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:66
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\a0"                       ;; "\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:81
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\bf"                       ;; "\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:98
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\c2\\80\\80"                 ;; "\\c2\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:113
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\c2"                       ;; "\\c2"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:128
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c2\\2e"                    ;; "\\c2."
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:145
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c0\\80"                    ;; "\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:160
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c0\\bf"                    ;; "\\c0\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:175
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c1\\80"                    ;; "\\c1\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:190
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c1\\bf"                    ;; "\\c1\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:205
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c2\\00"                    ;; "\\c2\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:220
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c2\\7f"                    ;; "\\c2\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:235
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c2\\c0"                    ;; "\\c2\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:250
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\c2\\fd"                    ;; "\\c2\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:265
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\df\\00"                    ;; "\\df\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:280
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\df\\7f"                    ;; "\\df\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:295
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\df\\c0"                    ;; "\\df\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:310
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\df\\fd"                    ;; "\\df\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:327
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\e1\\80\\80\\80"              ;; "\\e1\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:342
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\e1\\80"                    ;; "\\e1\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:357
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\80\\2e"                 ;; "\\e1\\80."
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:372
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\e1"                       ;; "\\e1"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:387
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\e1\\2e"                    ;; "\\e1."
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:404
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\00\\a0"                 ;; "\\e0\\00\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:419
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\7f\\a0"                 ;; "\\e0\\7f\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:434
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\80\\80"                 ;; "\\e0\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:449
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\80\\a0"                 ;; "\\e0\\80\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:464
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\9f\\a0"                 ;; "\\e0\\9f\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:479
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\9f\\bf"                 ;; "\\e0\\9f\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:494
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\c0\\a0"                 ;; "\\e0\\c0\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:509
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\fd\\a0"                 ;; "\\e0\\fd\\a0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:524
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\00\\80"                 ;; "\\e1\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:539
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\7f\\80"                 ;; "\\e1\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:554
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\c0\\80"                 ;; "\\e1\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:569
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\fd\\80"                 ;; "\\e1\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:584
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\00\\80"                 ;; "\\ec\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:599
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\7f\\80"                 ;; "\\ec\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:614
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\c0\\80"                 ;; "\\ec\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:629
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\fd\\80"                 ;; "\\ec\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:644
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\00\\80"                 ;; "\\ed\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:659
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\7f\\80"                 ;; "\\ed\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:674
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\a0\\80"                 ;; "\\ed\\a0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:689
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\a0\\bf"                 ;; "\\ed\\a0\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:704
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\bf\\80"                 ;; "\\ed\\bf\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:719
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\bf\\bf"                 ;; "\\ed\\bf\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:734
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\c0\\80"                 ;; "\\ed\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:749
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\fd\\80"                 ;; "\\ed\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:764
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\00\\80"                 ;; "\\ee\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:779
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\7f\\80"                 ;; "\\ee\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:794
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\c0\\80"                 ;; "\\ee\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:809
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\fd\\80"                 ;; "\\ee\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:824
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\00\\80"                 ;; "\\ef\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:839
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\7f\\80"                 ;; "\\ef\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:854
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\c0\\80"                 ;; "\\ef\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:869
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\fd\\80"                 ;; "\\ef\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:886
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\a0\\00"                 ;; "\\e0\\a0\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:901
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\a0\\7f"                 ;; "\\e0\\a0\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:916
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\a0\\c0"                 ;; "\\e0\\a0\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:931
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e0\\a0\\fd"                 ;; "\\e0\\a0\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:946
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\80\\00"                 ;; "\\e1\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:961
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\80\\7f"                 ;; "\\e1\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:976
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\80\\c0"                 ;; "\\e1\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:991
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\e1\\80\\fd"                 ;; "\\e1\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1006
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\80\\00"                 ;; "\\ec\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1021
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\80\\7f"                 ;; "\\ec\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1036
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\80\\c0"                 ;; "\\ec\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1051
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ec\\80\\fd"                 ;; "\\ec\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1066
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\80\\00"                 ;; "\\ed\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1081
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\80\\7f"                 ;; "\\ed\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1096
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\80\\c0"                 ;; "\\ed\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1111
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ed\\80\\fd"                 ;; "\\ed\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1126
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\80\\00"                 ;; "\\ee\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1141
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\80\\7f"                 ;; "\\ee\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1156
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\80\\c0"                 ;; "\\ee\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1171
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ee\\80\\fd"                 ;; "\\ee\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1186
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\80\\00"                 ;; "\\ef\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1201
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\80\\7f"                 ;; "\\ef\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1216
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\80\\c0"                 ;; "\\ef\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1231
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\ef\\80\\fd"                 ;; "\\ef\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1248
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\05\\f1\\80\\80\\80\\80"           ;; "\\f1\\80\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1263
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\f1\\80\\80"                 ;; "\\f1\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1278
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\80\\23"              ;; "\\f1\\80\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1293
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\f1\\80"                    ;; "\\f1\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1308
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\f1\\80\\23"                 ;; "\\f1\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1323
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\f1"                       ;; "\\f1"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1338
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\f1\\23"                    ;; "\\f1#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1355
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\00\\90\\90"              ;; "\\f0\\00\\90\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1370
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\7f\\90\\90"              ;; "\\f0\\7f\\90\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1385
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\80\\80\\80"              ;; "\\f0\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1400
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\80\\90\\90"              ;; "\\f0\\80\\90\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1415
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\8f\\90\\90"              ;; "\\f0\\8f\\90\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1430
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\8f\\bf\\bf"              ;; "\\f0\\8f\\bf\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1445
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\c0\\90\\90"              ;; "\\f0\\c0\\90\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1460
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\fd\\90\\90"              ;; "\\f0\\fd\\90\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1475
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\00\\80\\80"              ;; "\\f1\\00\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1490
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\7f\\80\\80"              ;; "\\f1\\7f\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1505
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\c0\\80\\80"              ;; "\\f1\\c0\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1520
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\fd\\80\\80"              ;; "\\f1\\fd\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1535
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\00\\80\\80"              ;; "\\f3\\00\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1550
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\7f\\80\\80"              ;; "\\f3\\7f\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1565
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\c0\\80\\80"              ;; "\\f3\\c0\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1580
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\fd\\80\\80"              ;; "\\f3\\fd\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1595
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\00\\80\\80"              ;; "\\f4\\00\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1610
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\7f\\80\\80"              ;; "\\f4\\7f\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1625
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\90\\80\\80"              ;; "\\f4\\90\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1640
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\bf\\80\\80"              ;; "\\f4\\bf\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1655
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\c0\\80\\80"              ;; "\\f4\\c0\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1670
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\fd\\80\\80"              ;; "\\f4\\fd\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1685
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f5\\80\\80\\80"              ;; "\\f5\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1700
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f7\\80\\80\\80"              ;; "\\f7\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1715
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f7\\bf\\bf\\bf"              ;; "\\f7\\bf\\bf\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1732
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\00\\90"              ;; "\\f0\\90\\00\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1747
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\7f\\90"              ;; "\\f0\\90\\7f\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1762
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\c0\\90"              ;; "\\f0\\90\\c0\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1777
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\fd\\90"              ;; "\\f0\\90\\fd\\90"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1792
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\00\\80"              ;; "\\f1\\80\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1807
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\7f\\80"              ;; "\\f1\\80\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1822
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\c0\\80"              ;; "\\f1\\80\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1837
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\fd\\80"              ;; "\\f1\\80\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1852
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\00\\80"              ;; "\\f3\\80\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1867
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\7f\\80"              ;; "\\f3\\80\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1882
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\c0\\80"              ;; "\\f3\\80\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1897
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\fd\\80"              ;; "\\f3\\80\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1912
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\00\\80"              ;; "\\f4\\80\\00\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1927
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\7f\\80"              ;; "\\f4\\80\\7f\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1942
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\c0\\80"              ;; "\\f4\\80\\c0\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1957
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\fd\\80"              ;; "\\f4\\80\\fd\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1974
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\90\\00"              ;; "\\f0\\90\\90\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:1989
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\90\\7f"              ;; "\\f0\\90\\90\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2004
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\90\\c0"              ;; "\\f0\\90\\90\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2019
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f0\\90\\90\\fd"              ;; "\\f0\\90\\90\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2034
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\80\\00"              ;; "\\f1\\80\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2049
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\80\\7f"              ;; "\\f1\\80\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2064
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\80\\c0"              ;; "\\f1\\80\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2079
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f1\\80\\80\\fd"              ;; "\\f1\\80\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2094
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\80\\00"              ;; "\\f3\\80\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2109
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\80\\7f"              ;; "\\f3\\80\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2124
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\80\\c0"              ;; "\\f3\\80\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2139
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f3\\80\\80\\fd"              ;; "\\f3\\80\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2154
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\80\\00"              ;; "\\f4\\80\\80\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2169
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\80\\7f"              ;; "\\f4\\80\\80\\7f"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2184
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\80\\c0"              ;; "\\f4\\80\\80\\c0"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2199
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f4\\80\\80\\fd"              ;; "\\f4\\80\\80\\fd"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2216
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\06\\f8\\80\\80\\80\\80\\80"        ;; "\\f8\\80\\80\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2231
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f8\\80\\80\\80"              ;; "\\f8\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2246
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\05\\f8\\80\\80\\80\\23"           ;; "\\f8\\80\\80\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2261
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\f8\\80\\80"                 ;; "\\f8\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2276
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\f8\\80\\80\\23"              ;; "\\f8\\80\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2291
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\f8\\80"                    ;; "\\f8\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2306
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\f8\\80\\23"                 ;; "\\f8\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2321
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\f8"                       ;; "\\f8"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2336
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\f8\\23"                    ;; "\\f8#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2353
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\05\\f8\\80\\80\\80\\80"           ;; "\\f8\\80\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2368
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\05\\fb\\bf\\bf\\bf\\bf"           ;; "\\fb\\bf\\bf\\bf\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2385
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\11"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\07\\fc\\80\\80\\80\\80\\80\\80"     ;; "\\fc\\80\\80\\80\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2400
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\05\\fc\\80\\80\\80\\80"           ;; "\\fc\\80\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2415
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\06\\fc\\80\\80\\80\\80\\23"        ;; "\\fc\\80\\80\\80\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2430
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\fc\\80\\80\\80"              ;; "\\fc\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2445
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\05\\fc\\80\\80\\80\\23"           ;; "\\fc\\80\\80\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2460
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\fc\\80\\80"                 ;; "\\fc\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2475
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\fc\\80\\80\\23"              ;; "\\fc\\80\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2490
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\fc\\80"                    ;; "\\fc\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2505
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\03\\fc\\80\\23"                 ;; "\\fc\\80#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2520
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\fc"                       ;; "\\fc"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2535
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\fc\\23"                    ;; "\\fc#"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2552
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\06\\fc\\80\\80\\80\\80\\80"        ;; "\\fc\\80\\80\\80\\80\\80"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2567
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\06\\fd\\bf\\bf\\bf\\bf\\bf"        ;; "\\fd\\bf\\bf\\bf\\bf\\bf"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2584
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\fe"                       ;; "\\fe"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2599
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\01\\ff"                       ;; "\\ff"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2614
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\fe\\ff"                    ;; "\\fe\\ff"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2629
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\00\\00\\fe\\ff"              ;; "\\00\\00\\fe\\ff"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2644
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\02\\ff\\fe"                    ;; "\\ff\\fe"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-field.wast:2659
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\ff\\fe\\00\\00"              ;; "\\ff\\fe\\00\\00"
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/utf8-import-module.wast.js b/js/src/jit-test/tests/wasm/spec/spec/utf8-import-module.wast.js
new file mode 100644
index 0000000000..8175cd2d2f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/utf8-import-module.wast.js
@@ -0,0 +1,2656 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/utf8-import-module.wast
+
+// ./test/core/utf8-import-module.wast:6
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\80"                       ;; "\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:21
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\8f"                       ;; "\\8f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:36
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\90"                       ;; "\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:51
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\9f"                       ;; "\\9f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:66
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\a0"                       ;; "\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:81
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\bf"                       ;; "\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:98
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\c2\\80\\80"                 ;; "\\c2\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:113
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\c2"                       ;; "\\c2"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:128
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c2\\2e"                    ;; "\\c2."
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:145
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c0\\80"                    ;; "\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:160
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c0\\bf"                    ;; "\\c0\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:175
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c1\\80"                    ;; "\\c1\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:190
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c1\\bf"                    ;; "\\c1\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:205
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c2\\00"                    ;; "\\c2\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:220
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c2\\7f"                    ;; "\\c2\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:235
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c2\\c0"                    ;; "\\c2\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:250
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\c2\\fd"                    ;; "\\c2\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:265
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\df\\00"                    ;; "\\df\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:280
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\df\\7f"                    ;; "\\df\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:295
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\df\\c0"                    ;; "\\df\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:310
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\df\\fd"                    ;; "\\df\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:327
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\e1\\80\\80\\80"              ;; "\\e1\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:342
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\e1\\80"                    ;; "\\e1\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:357
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\80\\2e"                 ;; "\\e1\\80."
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:372
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\e1"                       ;; "\\e1"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:387
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\e1\\2e"                    ;; "\\e1."
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:404
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\00\\a0"                 ;; "\\e0\\00\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:419
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\7f\\a0"                 ;; "\\e0\\7f\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:434
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\80\\80"                 ;; "\\e0\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:449
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\80\\a0"                 ;; "\\e0\\80\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:464
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\9f\\a0"                 ;; "\\e0\\9f\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:479
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\9f\\bf"                 ;; "\\e0\\9f\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:494
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\c0\\a0"                 ;; "\\e0\\c0\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:509
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\fd\\a0"                 ;; "\\e0\\fd\\a0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:524
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\00\\80"                 ;; "\\e1\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:539
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\7f\\80"                 ;; "\\e1\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:554
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\c0\\80"                 ;; "\\e1\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:569
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\fd\\80"                 ;; "\\e1\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:584
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\00\\80"                 ;; "\\ec\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:599
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\7f\\80"                 ;; "\\ec\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:614
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\c0\\80"                 ;; "\\ec\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:629
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\fd\\80"                 ;; "\\ec\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:644
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\00\\80"                 ;; "\\ed\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:659
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\7f\\80"                 ;; "\\ed\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:674
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\a0\\80"                 ;; "\\ed\\a0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:689
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\a0\\bf"                 ;; "\\ed\\a0\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:704
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\bf\\80"                 ;; "\\ed\\bf\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:719
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\bf\\bf"                 ;; "\\ed\\bf\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:734
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\c0\\80"                 ;; "\\ed\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:749
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\fd\\80"                 ;; "\\ed\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:764
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\00\\80"                 ;; "\\ee\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:779
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\7f\\80"                 ;; "\\ee\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:794
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\c0\\80"                 ;; "\\ee\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:809
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\fd\\80"                 ;; "\\ee\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:824
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\00\\80"                 ;; "\\ef\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:839
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\7f\\80"                 ;; "\\ef\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:854
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\c0\\80"                 ;; "\\ef\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:869
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\fd\\80"                 ;; "\\ef\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:886
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\a0\\00"                 ;; "\\e0\\a0\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:901
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\a0\\7f"                 ;; "\\e0\\a0\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:916
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\a0\\c0"                 ;; "\\e0\\a0\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:931
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e0\\a0\\fd"                 ;; "\\e0\\a0\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:946
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\80\\00"                 ;; "\\e1\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:961
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\80\\7f"                 ;; "\\e1\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:976
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\80\\c0"                 ;; "\\e1\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:991
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\e1\\80\\fd"                 ;; "\\e1\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1006
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\80\\00"                 ;; "\\ec\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1021
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\80\\7f"                 ;; "\\ec\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1036
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\80\\c0"                 ;; "\\ec\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1051
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ec\\80\\fd"                 ;; "\\ec\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1066
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\80\\00"                 ;; "\\ed\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1081
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\80\\7f"                 ;; "\\ed\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1096
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\80\\c0"                 ;; "\\ed\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1111
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ed\\80\\fd"                 ;; "\\ed\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1126
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\80\\00"                 ;; "\\ee\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1141
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\80\\7f"                 ;; "\\ee\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1156
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\80\\c0"                 ;; "\\ee\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1171
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ee\\80\\fd"                 ;; "\\ee\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1186
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\80\\00"                 ;; "\\ef\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1201
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\80\\7f"                 ;; "\\ef\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1216
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\80\\c0"                 ;; "\\ef\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1231
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\ef\\80\\fd"                 ;; "\\ef\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1248
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\05\\f1\\80\\80\\80\\80"           ;; "\\f1\\80\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1263
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\f1\\80\\80"                 ;; "\\f1\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1278
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\80\\23"              ;; "\\f1\\80\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1293
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\f1\\80"                    ;; "\\f1\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1308
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\f1\\80\\23"                 ;; "\\f1\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1323
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\f1"                       ;; "\\f1"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1338
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\f1\\23"                    ;; "\\f1#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1355
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\00\\90\\90"              ;; "\\f0\\00\\90\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1370
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\7f\\90\\90"              ;; "\\f0\\7f\\90\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1385
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\80\\80\\80"              ;; "\\f0\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1400
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\80\\90\\90"              ;; "\\f0\\80\\90\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1415
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\8f\\90\\90"              ;; "\\f0\\8f\\90\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1430
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\8f\\bf\\bf"              ;; "\\f0\\8f\\bf\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1445
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\c0\\90\\90"              ;; "\\f0\\c0\\90\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1460
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\fd\\90\\90"              ;; "\\f0\\fd\\90\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1475
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\00\\80\\80"              ;; "\\f1\\00\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1490
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\7f\\80\\80"              ;; "\\f1\\7f\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1505
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\c0\\80\\80"              ;; "\\f1\\c0\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1520
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\fd\\80\\80"              ;; "\\f1\\fd\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1535
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\00\\80\\80"              ;; "\\f3\\00\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1550
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\7f\\80\\80"              ;; "\\f3\\7f\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1565
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\c0\\80\\80"              ;; "\\f3\\c0\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1580
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\fd\\80\\80"              ;; "\\f3\\fd\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1595
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\00\\80\\80"              ;; "\\f4\\00\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1610
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\7f\\80\\80"              ;; "\\f4\\7f\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1625
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\90\\80\\80"              ;; "\\f4\\90\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1640
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\bf\\80\\80"              ;; "\\f4\\bf\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1655
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\c0\\80\\80"              ;; "\\f4\\c0\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1670
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\fd\\80\\80"              ;; "\\f4\\fd\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1685
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f5\\80\\80\\80"              ;; "\\f5\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1700
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f7\\80\\80\\80"              ;; "\\f7\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1715
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f7\\bf\\bf\\bf"              ;; "\\f7\\bf\\bf\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1732
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\00\\90"              ;; "\\f0\\90\\00\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1747
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\7f\\90"              ;; "\\f0\\90\\7f\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1762
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\c0\\90"              ;; "\\f0\\90\\c0\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1777
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\fd\\90"              ;; "\\f0\\90\\fd\\90"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1792
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\00\\80"              ;; "\\f1\\80\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1807
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\7f\\80"              ;; "\\f1\\80\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1822
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\c0\\80"              ;; "\\f1\\80\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1837
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\fd\\80"              ;; "\\f1\\80\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1852
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\00\\80"              ;; "\\f3\\80\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1867
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\7f\\80"              ;; "\\f3\\80\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1882
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\c0\\80"              ;; "\\f3\\80\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1897
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\fd\\80"              ;; "\\f3\\80\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1912
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\00\\80"              ;; "\\f4\\80\\00\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1927
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\7f\\80"              ;; "\\f4\\80\\7f\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1942
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\c0\\80"              ;; "\\f4\\80\\c0\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1957
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\fd\\80"              ;; "\\f4\\80\\fd\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1974
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\90\\00"              ;; "\\f0\\90\\90\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:1989
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\90\\7f"              ;; "\\f0\\90\\90\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2004
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\90\\c0"              ;; "\\f0\\90\\90\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2019
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f0\\90\\90\\fd"              ;; "\\f0\\90\\90\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2034
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\80\\00"              ;; "\\f1\\80\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2049
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\80\\7f"              ;; "\\f1\\80\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2064
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\80\\c0"              ;; "\\f1\\80\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2079
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f1\\80\\80\\fd"              ;; "\\f1\\80\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2094
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\80\\00"              ;; "\\f3\\80\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2109
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\80\\7f"              ;; "\\f3\\80\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2124
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\80\\c0"              ;; "\\f3\\80\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2139
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f3\\80\\80\\fd"              ;; "\\f3\\80\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2154
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\80\\00"              ;; "\\f4\\80\\80\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2169
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\80\\7f"              ;; "\\f4\\80\\80\\7f"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2184
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\80\\c0"              ;; "\\f4\\80\\80\\c0"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2199
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f4\\80\\80\\fd"              ;; "\\f4\\80\\80\\fd"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2216
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\06\\f8\\80\\80\\80\\80\\80"        ;; "\\f8\\80\\80\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2231
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f8\\80\\80\\80"              ;; "\\f8\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2246
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\05\\f8\\80\\80\\80\\23"           ;; "\\f8\\80\\80\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2261
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\f8\\80\\80"                 ;; "\\f8\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2276
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\f8\\80\\80\\23"              ;; "\\f8\\80\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2291
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\f8\\80"                    ;; "\\f8\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2306
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\f8\\80\\23"                 ;; "\\f8\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2321
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\f8"                       ;; "\\f8"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2336
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\f8\\23"                    ;; "\\f8#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2353
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\05\\f8\\80\\80\\80\\80"           ;; "\\f8\\80\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2368
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\05\\fb\\bf\\bf\\bf\\bf"           ;; "\\fb\\bf\\bf\\bf\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2385
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\11"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\07\\fc\\80\\80\\80\\80\\80\\80"     ;; "\\fc\\80\\80\\80\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2400
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\05\\fc\\80\\80\\80\\80"           ;; "\\fc\\80\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2415
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\06\\fc\\80\\80\\80\\80\\23"        ;; "\\fc\\80\\80\\80\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2430
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\fc\\80\\80\\80"              ;; "\\fc\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2445
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0f"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\05\\fc\\80\\80\\80\\23"           ;; "\\fc\\80\\80\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2460
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\fc\\80\\80"                 ;; "\\fc\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2475
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\fc\\80\\80\\23"              ;; "\\fc\\80\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2490
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\fc\\80"                    ;; "\\fc\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2505
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0d"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\03\\fc\\80\\23"                 ;; "\\fc\\80#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2520
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\fc"                       ;; "\\fc"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2535
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\fc\\23"                    ;; "\\fc#"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2552
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\06\\fc\\80\\80\\80\\80\\80"        ;; "\\fc\\80\\80\\80\\80\\80"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2567
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\10"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\06\\fd\\bf\\bf\\bf\\bf\\bf"        ;; "\\fd\\bf\\bf\\bf\\bf\\bf"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2584
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\fe"                       ;; "\\fe"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2599
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0b"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\01\\ff"                       ;; "\\ff"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2614
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\fe\\ff"                    ;; "\\fe\\ff"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2629
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\00\\00\\fe\\ff"              ;; "\\00\\00\\fe\\ff"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2644
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0c"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\02\\ff\\fe"                    ;; "\\ff\\fe"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-import-module.wast:2659
+assert_malformed(
+  () => instantiate(`(module binary
+    "\\00asm" "\\01\\00\\00\\00"
+    "\\02\\0e"                       ;; import section
+    "\\01"                          ;; length 1
+    "\\04\\74\\65\\73\\74"              ;; "test"
+    "\\04\\ff\\fe\\00\\00"              ;; "\\ff\\fe\\00\\00"
+    "\\03"                          ;; GlobalImport
+    "\\7f"                          ;; i32
+    "\\00"                          ;; immutable
+  )`),
+  `malformed UTF-8 encoding`,
+);
diff --git a/js/src/jit-test/tests/wasm/spec/spec/utf8-invalid-encoding.wast.js b/js/src/jit-test/tests/wasm/spec/spec/utf8-invalid-encoding.wast.js
new file mode 100644
index 0000000000..e0fe95f69d
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/utf8-invalid-encoding.wast.js
@@ -0,0 +1,1033 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/utf8-invalid-encoding.wast
+
+// ./test/core/utf8-invalid-encoding.wast:1
+assert_malformed(
+  () => instantiate(`(func (export "\\00\\00\\fe\\ff")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:2
+assert_malformed(() => instantiate(`(func (export "\\80")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:3
+assert_malformed(() => instantiate(`(func (export "\\8f")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:4
+assert_malformed(() => instantiate(`(func (export "\\90")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:5
+assert_malformed(() => instantiate(`(func (export "\\9f")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:6
+assert_malformed(() => instantiate(`(func (export "\\a0")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:7
+assert_malformed(() => instantiate(`(func (export "\\bf")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:8
+assert_malformed(
+  () => instantiate(`(func (export "\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:9
+assert_malformed(
+  () => instantiate(`(func (export "\\c0\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:10
+assert_malformed(
+  () => instantiate(`(func (export "\\c1\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:11
+assert_malformed(
+  () => instantiate(`(func (export "\\c1\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:12
+assert_malformed(
+  () => instantiate(`(func (export "\\c2\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:13
+assert_malformed(
+  () => instantiate(`(func (export "\\c2\\2e")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:14
+assert_malformed(
+  () => instantiate(`(func (export "\\c2\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:15
+assert_malformed(
+  () => instantiate(`(func (export "\\c2\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:16
+assert_malformed(
+  () => instantiate(`(func (export "\\c2\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:17
+assert_malformed(() => instantiate(`(func (export "\\c2")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:18
+assert_malformed(
+  () => instantiate(`(func (export "\\c2\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:19
+assert_malformed(
+  () => instantiate(`(func (export "\\df\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:20
+assert_malformed(
+  () => instantiate(`(func (export "\\df\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:21
+assert_malformed(
+  () => instantiate(`(func (export "\\df\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:22
+assert_malformed(
+  () => instantiate(`(func (export "\\df\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:23
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\00\\a0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:24
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\7f\\a0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:25
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:26
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\80\\a0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:27
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\9f\\a0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:28
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\9f\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:29
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\a0\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:30
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\a0\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:31
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\a0\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:32
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\a0\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:33
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\c0\\a0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:34
+assert_malformed(
+  () => instantiate(`(func (export "\\e0\\fd\\a0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:35
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:36
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\2e")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:37
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:38
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:39
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80\\2e")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:40
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:41
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:42
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:43
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:44
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:45
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:46
+assert_malformed(() => instantiate(`(func (export "\\e1")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:47
+assert_malformed(
+  () => instantiate(`(func (export "\\e1\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:48
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:49
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:50
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:51
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:52
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:53
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:54
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:55
+assert_malformed(
+  () => instantiate(`(func (export "\\ec\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:56
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:57
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:58
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:59
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:60
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:61
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:62
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\a0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:63
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\a0\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:64
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\bf\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:65
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\bf\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:66
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:67
+assert_malformed(
+  () => instantiate(`(func (export "\\ed\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:68
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:69
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:70
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:71
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:72
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:73
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:74
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:75
+assert_malformed(
+  () => instantiate(`(func (export "\\ee\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:76
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:77
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:78
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:79
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:80
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:81
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:82
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:83
+assert_malformed(
+  () => instantiate(`(func (export "\\ef\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:84
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\00\\90\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:85
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\7f\\90\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:86
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:87
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\80\\90\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:88
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\8f\\90\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:89
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\8f\\bf\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:90
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\00\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:91
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\7f\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:92
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\90\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:93
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\90\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:94
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\90\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:95
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\90\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:96
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\c0\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:97
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\90\\fd\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:98
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\c0\\90\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:99
+assert_malformed(
+  () => instantiate(`(func (export "\\f0\\fd\\90\\90")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:100
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\00\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:101
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:102
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\7f\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:103
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:104
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:105
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:106
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:107
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:108
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:109
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:110
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:111
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:112
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:113
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:114
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:115
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\80\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:116
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\c0\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:117
+assert_malformed(() => instantiate(`(func (export "\\f1")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:118
+assert_malformed(
+  () => instantiate(`(func (export "\\f1\\fd\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:119
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\00\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:120
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\7f\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:121
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:122
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:123
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:124
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:125
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:126
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:127
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:128
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\80\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:129
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\c0\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:130
+assert_malformed(
+  () => instantiate(`(func (export "\\f3\\fd\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:131
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\00\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:132
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\7f\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:133
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\00\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:134
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\7f\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:135
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\80\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:136
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\80\\7f")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:137
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\80\\c0")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:138
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\80\\fd")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:139
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\c0\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:140
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\80\\fd\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:141
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\90\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:142
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\bf\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:143
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\c0\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:144
+assert_malformed(
+  () => instantiate(`(func (export "\\f4\\fd\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:145
+assert_malformed(
+  () => instantiate(`(func (export "\\f5\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:146
+assert_malformed(
+  () => instantiate(`(func (export "\\f7\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:147
+assert_malformed(
+  () => instantiate(`(func (export "\\f7\\bf\\bf\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:148
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:149
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:150
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:151
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\80\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:152
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\80\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:153
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:154
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:155
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:156
+assert_malformed(
+  () => instantiate(`(func (export "\\f8\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:157
+assert_malformed(() => instantiate(`(func (export "\\f8")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:158
+assert_malformed(
+  () => instantiate(`(func (export "\\fb\\bf\\bf\\bf\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:159
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:160
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:161
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:162
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:163
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\80\\80\\23")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:164
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\80\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:165
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:166
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:167
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:168
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:169
+assert_malformed(
+  () => instantiate(`(func (export "\\fc\\80")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:170
+assert_malformed(() => instantiate(`(func (export "\\fc")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:171
+assert_malformed(
+  () => instantiate(`(func (export "\\fd\\bf\\bf\\bf\\bf\\bf")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:172
+assert_malformed(() => instantiate(`(func (export "\\fe")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:173
+assert_malformed(
+  () => instantiate(`(func (export "\\fe\\ff")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:174
+assert_malformed(() => instantiate(`(func (export "\\ff")) `), `malformed UTF-8 encoding`);
+
+// ./test/core/utf8-invalid-encoding.wast:175
+assert_malformed(
+  () => instantiate(`(func (export "\\ff\\fe\\00\\00")) `),
+  `malformed UTF-8 encoding`,
+);
+
+// ./test/core/utf8-invalid-encoding.wast:176
+assert_malformed(
+  () => instantiate(`(func (export "\\ff\\fe")) `),
+  `malformed UTF-8 encoding`,
+);
diff --git a/js/src/jit-test/tests/wasm/stack.js b/js/src/jit-test/tests/wasm/stack.js
new file mode 100644
index 0000000000..c6fc06456c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/stack.js
@@ -0,0 +1,67 @@
+// Test instructions with no return value interposed between pushes and pops.
+wasmFullPass(` (module
+   (memory 1)
+
+   (func (result i32)
+     (local $local f64)
+     i32.const 0
+     i32.const 16
+     i32.store
+     i32.const 0
+     i32.load
+     i32.const 0
+     if
+       i32.const 0
+       call $returnVoid
+       i32.const 21
+       i32.store
+       i32.const 22
+       drop
+     else
+       i32.const 0
+       i32.const 17
+       i32.store
+     end
+     block (result i32)
+     block (result i32)
+     i32.const 2
+     if (result i32)
+       i32.const 500
+     else
+       i32.const 501
+     end
+     end
+     end
+     drop
+     i32.const 0
+     i32.load
+     f64.const 5.0
+     local.set $local
+     f64.const 5.0
+     tee_local $local
+     drop
+     block
+       i32.const 0
+       i32.const 18
+       i32.store
+       nop
+       i32.const 0
+       i32.const 19
+       call $returnVoid
+       i32.store
+       loop
+         i32.const 1
+         if
+           i32.const 0
+           i32.const 20
+           i32.store
+         end
+       end
+     end
+     i32.add
+   )
+
+   (func $returnVoid)
+
+   (export "run" (func 0))
+)`, 33);
diff --git a/js/src/jit-test/tests/wasm/start.js b/js/src/jit-test/tests/wasm/start.js
new file mode 100644
index 0000000000..2591d30321
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/start.js
@@ -0,0 +1,49 @@
+assertErrorMessage(() => wasmEvalText('(module (func) (start 0) (start 0))'), SyntaxError, /wasm text error/);
+assertErrorMessage(() => wasmEvalText('(module (func) (start $unknown))'), SyntaxError, /failed to find/);
+
+wasmFailValidateText('(module (func) (start 1))', /unknown start function/);
+wasmFailValidateText('(module (func (param i32)) (start 0))', /must be nullary/);
+wasmFailValidateText('(module (func (param i32) (param f32)) (start 0))', /must be nullary/);
+wasmFailValidateText('(module (func (param i32) (param f32) (param f64)) (start 0))', /must be nullary/);
+wasmFailValidateText('(module (func (result f32)) (start 0))', /must not return anything/);
+
+// Basic use case.
+var count = 0;
+function inc() { count++; }
+var exports = wasmEvalText(`(module (import "" "inc" (func $imp)) (func $f (call $imp)) (start $f))`, { "":{inc} }).exports;
+assertEq(count, 1);
+assertEq(Object.keys(exports).length, 0);
+
+count = 0;
+exports = wasmEvalText(`(module (import "" "inc" (func)) (func $start (call 0)) (start $start) (export "" (func 0)))`, { "":{inc} }).exports;
+assertEq(count, 1);
+assertEq(typeof exports[""], 'function');
+assertEq(exports[""](), undefined);
+assertEq(count, 2);
+
+// New API.
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+
+count = 0;
+const m = new Module(wasmTextToBinary('(module (import "" "inc" (func $imp)) (func) (func $start (call $imp)) (start $start) (export "" (func $start)))'));
+assertEq(count, 0);
+
+assertErrorMessage(() => new Instance(m), TypeError, /second argument must be an object/);
+assertEq(count, 0);
+
+const i1 = new Instance(m, { "":{inc} });
+assertEq(count, 1);
+i1.exports[""]();
+assertEq(count, 2);
+
+const i2 = new Instance(m, { "":{inc} });
+assertEq(count, 3);
+
+function fail() { assertEq(true, false); }
+
+count = 0;
+const m2 = new Module(wasmTextToBinary('(module (import "" "fail" (func)) (import "" "inc" (func $imp)) (func) (start $imp))'));
+assertEq(count, 0);
+new Instance(m2, {"":{ inc, fail }});
+assertEq(count, 1);
diff --git a/js/src/jit-test/tests/wasm/stealing.js b/js/src/jit-test/tests/wasm/stealing.js
new file mode 100644
index 0000000000..6e4e60b9b1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/stealing.js
@@ -0,0 +1,17 @@
+var exp = wasmEvalText(`(module
+    (memory 1)
+    (export "mem" (memory 0))
+    (func $f (result i32) (i32.load (i32.const 0)))
+    (export "f" (func $f))
+)`).exports;
+
+var ab = exp.mem.buffer;
+new Int32Array(ab)[0] = 42;
+
+assertEq(exp.f(), 42);
+
+assertThrowsInstanceOf(() => detachArrayBuffer(ab), Error);
+assertEq(exp.f(), 42);
+
+assertThrowsInstanceOf(() => serialize(ab, [ab]), Error);
+assertEq(exp.f(), 42);
diff --git a/js/src/jit-test/tests/wasm/streaming.js b/js/src/jit-test/tests/wasm/streaming.js
new file mode 100644
index 0000000000..d87abe37be
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/streaming.js
@@ -0,0 +1,99 @@
+// |jit-test| skip-if: !wasmStreamingEnabled()
+
+load(libdir + "wasm-binary.js");
+
+function testInstantiate(source, importObj, exportName, expectedValue) {
+    var result;
+    WebAssembly.instantiateStreaming(code, importObj).then(r => { result = r });
+    drainJobQueue();
+    assertEq(result !== undefined, true);
+    assertEq(result.module instanceof WebAssembly.Module, true);
+    assertEq(result.instance instanceof WebAssembly.Instance, true);
+    assertEq(result.instance.exports[exportName](), expectedValue);
+}
+function testBoth(source, exportName, expectedValue) {
+    var module;
+    WebAssembly.compileStreaming(code).then(m => { module = m });
+    drainJobQueue();
+    assertEq(module !== undefined, true);
+    assertEq(module instanceof WebAssembly.Module, true);
+    assertEq(new WebAssembly.Instance(module).exports[exportName](), expectedValue);
+
+    testInstantiate(source, undefined, exportName, expectedValue);
+}
+
+function testFailInstantiate(source, importObj, error) {
+    var caught = false;
+    WebAssembly.instantiateStreaming(source).catch(err => {
+        assertEq(err instanceof error, true);
+        caught = true;
+    });
+    drainJobQueue();
+    assertEq(caught, true);
+}
+function testFailBoth(source, error) {
+    var caught = false;
+    WebAssembly.compileStreaming(source).catch(err => {
+        assertEq(err instanceof error, true);
+        caught = true;
+    });
+    drainJobQueue();
+    assertEq(caught, true);
+
+    testFailInstantiate(source, undefined, error);
+}
+
+var code = wasmTextToBinary('(module (func (export "run") (result i32) i32.const 42))');
+testBoth(code, 'run', 42);
+testFailBoth(42, TypeError);
+testBoth(Promise.resolve(code), 'run', 42);
+testFailBoth(Promise.resolve(42), TypeError);
+testFailBoth(Promise.reject(new String("fail")), String);
+testBoth({then(resolve) { resolve(code) }}, 'run', 42);
+testFailBoth({then(resolve) { resolve(42) }}, TypeError);
+testFailBoth(new Promise((resolve, reject) => { reject(new Error("hi")) }), Error);
+testFailBoth(new Promise((resolve, reject) => { reject(new String("hi")) }), String);
+
+var code = wasmTextToBinary('(module (func $im (import "js" "foo") (result i32)) (func (export "run") (result i32) (i32.add (i32.const 1) (call $im))))');
+testInstantiate(code, {js:{foo() { return 42 }}}, 'run', 43);
+testFailInstantiate(code, null, TypeError);
+testFailInstantiate(code, {js:42}, TypeError);
+testFailInstantiate(code, {js:{foo:42}}, TypeError);
+
+var text = `(module\n`;
+text += ` (func (result i32) i32.const 0)\n`;
+for (var i = 1; i <= 200; i++)
+    text += ` (func (result i32) (i32.add (i32.const ${i}) (call ${i-1})))\n`;
+text += ` (func (export "run") (result i32) call 100)\n`;
+text += `)`;
+var code = wasmTextToBinary(text);
+
+// fuzzing-safe disables setBufferStreamParams
+if (typeof setBufferStreamParams == 'function') {
+    assertEq(code.length > 1000, true);
+    for ([delayMillis, chunkSize] of [[0, 10], [1, 10], [0, 100], [1, 100], [0, 1000], [1, 1000], [10, 1000]]) {
+        setBufferStreamParams(delayMillis, chunkSize);
+        testBoth(code, 'run', 5050);
+    }
+
+    setBufferStreamParams(1, 100);
+    var arr = [];
+    for (var i = 0; i < 10; i++)
+        arr.push(WebAssembly.instantiateStreaming(code));
+    var results;
+    Promise.all(arr).then(r => results = r);
+    drainJobQueue();
+    assertEq(results.length === 10, true);
+    for (var i = 0; i < 10; i++)
+        assertEq(results[i].instance.exports.run(), 5050);
+}
+
+// No code section, but data section:
+var code = wasmTextToBinary('(module (memory (import "js" "mem") 1) (data (i32.const 0) "a"))');
+var mem = new WebAssembly.Memory({initial:1});
+WebAssembly.instantiateStreaming(code, {js:{mem}});
+drainJobQueue();
+assertEq(new Uint8Array(mem.buffer)[0], 97);
+
+// Junk section before code section.
+testFailBoth(moduleWithSections([{name: 100, body: [1, 2, 3]}, bodySection([])]), WebAssembly.CompileError);
diff --git a/js/src/jit-test/tests/wasm/table-gc.js b/js/src/jit-test/tests/wasm/table-gc.js
new file mode 100644
index 0000000000..c96c70311f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/table-gc.js
@@ -0,0 +1,221 @@
+// |jit-test| --no-baseline; --no-blinterp
+// Turn off baseline and since it messes up the GC finalization assertions by
+// adding spurious edges to the GC graph.
+
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const Table = WebAssembly.Table;
+const RuntimeError = WebAssembly.RuntimeError;
+
+var caller = `(type $v2i (func (result i32))) (func $call (param $i i32) (result i32) (call_indirect (type $v2i) (local.get $i))) (export "call" (func $call))`
+var callee = i => `(func $f${i} (type $v2i) (i32.const ${i}))`;
+
+// A table should not hold exported functions alive and exported functions
+// should not hold their originating table alive. Live exported functions should
+// hold instances alive and instances hold imported tables alive. Nothing
+// should hold the export object alive.
+resetFinalizeCount();
+var i = wasmEvalText(`(module (table 2 funcref) (export "tbl" (table 0)) (elem (i32.const 0) $f0) ${callee(0)} ${caller})`);
+var e = i.exports;
+var t = e.tbl;
+var f = t.get(0);
+assertEq(f(), e.call(0));
+assertErrorMessage(() => e.call(1), RuntimeError, /indirect call to null/);
+assertErrorMessage(() => e.call(2), RuntimeError, /index out of bounds/);
+assertEq(finalizeCount(), 0);
+i.edge = makeFinalizeObserver();
+t.edge = makeFinalizeObserver();
+f.edge = makeFinalizeObserver();
+gc();
+assertEq(finalizeCount(), 0);
+f.x = 42;
+f = null;
+gc();
+assertEq(finalizeCount(), 0);
+f = t.get(0);
+assertEq(f.x, 42);
+gc();
+assertEq(finalizeCount(), 0);
+i.exports = null;
+e = null;
+gc();
+assertEq(finalizeCount(), 0);
+t = null;
+gc();
+assertEq(finalizeCount(), 0);
+i = null;
+gc();
+assertEq(finalizeCount(), 0);
+assertEq(f(), 0);
+f = null;
+gc();
+assertEq(finalizeCount(), 3);
+
+// A table should hold the instance of any of its elements alive.
+resetFinalizeCount();
+var i = wasmEvalText(`(module (table 1 funcref) (export "tbl" (table 0)) (elem (i32.const 0) $f0) ${callee(0)} ${caller})`);
+var e = i.exports;
+var t = e.tbl;
+var f = t.get(0);
+i.edge = makeFinalizeObserver();
+t.edge = makeFinalizeObserver();
+f.edge = makeFinalizeObserver();
+gc();
+assertEq(finalizeCount(), 0);
+i.exports = null;
+e = null;
+gc();
+assertEq(finalizeCount(), 0);
+f = null;
+gc();
+assertEq(finalizeCount(), 0);
+i = null;
+gc();
+assertEq(finalizeCount(), 0);
+t = null;
+gc();
+assertEq(finalizeCount(), 3);
+
+// Null elements shouldn't keep anything alive.
+resetFinalizeCount();
+var i = wasmEvalText(`(module (table 2 funcref) (export "tbl" (table 0)) ${caller})`);
+var e = i.exports;
+var t = e.tbl;
+i.edge = makeFinalizeObserver();
+t.edge = makeFinalizeObserver();
+gc();
+assertEq(finalizeCount(), 0);
+i.exports = null;
+e = null;
+gc();
+assertEq(finalizeCount(), 0);
+i = null;
+gc();
+assertEq(finalizeCount(), 1);
+t = null;
+gc();
+assertEq(finalizeCount(), 2);
+
+// Before initialization, a table is not bound to any instance.
+resetFinalizeCount();
+var i = wasmEvalText(`(module (func $f0 (result i32) (i32.const 0)) (export "f0" (func $f0)))`);
+var t = new Table({initial:4, element:"anyfunc"});
+i.edge = makeFinalizeObserver();
+t.edge = makeFinalizeObserver();
+gc();
+assertEq(finalizeCount(), 0);
+i = null;
+gc();
+assertEq(finalizeCount(), 1);
+t = null;
+gc();
+assertEq(finalizeCount(), 2);
+
+// When a Table is created (uninitialized) and then first assigned, it keeps the
+// first element's Instance alive (as above).
+resetFinalizeCount();
+var i = wasmEvalText(`(module (func $f (result i32) (i32.const 42)) (export "f" (func $f)))`);
+var f = i.exports.f;
+var t = new Table({initial:1, element:"anyfunc"});
+i.edge = makeFinalizeObserver();
+f.edge = makeFinalizeObserver();
+t.edge = makeFinalizeObserver();
+t.set(0, f);
+assertEq(t.get(0), f);
+assertEq(t.get(0)(), 42);
+gc();
+assertEq(finalizeCount(), 0);
+f = null;
+i.exports = null;
+gc();
+assertEq(finalizeCount(), 0);
+assertEq(t.get(0)(), 42);
+i = null;
+gc();
+assertEq(finalizeCount(), 0);
+t.set(0, null);
+assertEq(t.get(0), null);
+gc();
+assertEq(finalizeCount(), 2);
+t = null;
+gc();
+assertEq(finalizeCount(), 3);
+
+// Once all of an instance's elements in a Table have been clobbered, the
+// Instance should not be reachable.
+resetFinalizeCount();
+var i1 = wasmEvalText(`(module (func $f1 (result i32) (i32.const 13)) (export "f1" (func $f1)))`);
+var i2 = wasmEvalText(`(module (func $f2 (result i32) (i32.const 42)) (export "f2" (func $f2)))`);
+var f1 = i1.exports.f1;
+var f2 = i2.exports.f2;
+var t = new Table({initial:2, element:"anyfunc"});
+i1.edge = makeFinalizeObserver();
+i2.edge = makeFinalizeObserver();
+f1.edge = makeFinalizeObserver();
+f2.edge = makeFinalizeObserver();
+t.edge = makeFinalizeObserver();
+t.set(0, f1);
+t.set(1, f2);
+gc();
+assertEq(finalizeCount(), 0);
+f1 = f2 = null;
+i1.exports = null;
+i2.exports = null;
+gc();
+assertEq(finalizeCount(), 0);
+i1 = null;
+i2 = null;
+gc();
+assertEq(finalizeCount(), 0);
+t.set(0, t.get(1));
+gc();
+assertEq(finalizeCount(), 2);
+t.set(0, null);
+t.set(1, null);
+gc();
+assertEq(finalizeCount(), 4);
+t = null;
+gc();
+assertEq(finalizeCount(), 5);
+
+// Ensure that an instance that is only live on the stack cannot be GC even if
+// there are no outstanding references.
+resetFinalizeCount();
+const N = 10;
+var tbl = new Table({initial:N, element:"anyfunc"});
+tbl.edge = makeFinalizeObserver();
+function runTest() {
+    tbl = null;
+    gc();
+    assertEq(finalizeCount(), 0);
+    return 100;
+}
+var i = wasmEvalText(
+    `(module
+        (import "a" "b" (func $imp (result i32)))
+        (func $f (param i32) (result i32) (call $imp))
+        (export "f" (func $f))
+    )`,
+    {a:{b:runTest}}
+);
+i.edge = makeFinalizeObserver();
+tbl.set(0, i.exports.f);
+var m = new Module(wasmTextToBinary(`(module
+    (import "a" "b" (table ${N} funcref))
+    (type $i2i (func (param i32) (result i32)))
+    (func $f (param $i i32) (result i32)
+        (local.set $i (i32.sub (local.get $i) (i32.const 1)))
+        (i32.add
+            (i32.const 1)
+            (call_indirect (type $i2i) (local.get $i) (local.get $i))))
+    (export "f" (func $f))
+)`));
+for (var i = 1; i < N; i++) {
+    var inst = new Instance(m, {a:{b:tbl}});
+    inst.edge = makeFinalizeObserver();
+    tbl.set(i, inst.exports.f);
+}
+inst = null;
+assertEq(tbl.get(N - 1)(N - 1), 109);
+gc();
+assertEq(finalizeCount(), N + 1);
diff --git a/js/src/jit-test/tests/wasm/table-pre-barrier.js b/js/src/jit-test/tests/wasm/table-pre-barrier.js
new file mode 100644
index 0000000000..4069f634ab
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/table-pre-barrier.js
@@ -0,0 +1,22 @@
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const Table = WebAssembly.Table;
+
+var i42 = new Instance(new Module(wasmTextToBinary(`(module (func (result i32) (i32.const 42)) (export "f" (func 0)))`)));
+var i13 = new Instance(new Module(wasmTextToBinary(`(module (func (result i32) (i32.const 13)) (export "f" (func 0)))`)));
+var t = new Table({element:"anyfunc", initial:1});
+t.set(0, i42.exports.f);
+
+assertEq(t.get(0)(), 42);
+
+verifyprebarriers();
+t.set(0, i13.exports.f);
+verifyprebarriers();
+
+assertEq(t.get(0)(), 13);
+
+verifyprebarriers();
+t.set(0, null);
+verifyprebarriers();
+
+assertEq(t.get(0), null);
diff --git a/js/src/jit-test/tests/wasm/tables.js b/js/src/jit-test/tests/wasm/tables.js
new file mode 100644
index 0000000000..266e848e6b
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/tables.js
@@ -0,0 +1,308 @@
+const Module = WebAssembly.Module;
+const Instance = WebAssembly.Instance;
+const Table = WebAssembly.Table;
+const Memory = WebAssembly.Memory;
+const LinkError = WebAssembly.LinkError;
+const RuntimeError = WebAssembly.RuntimeError;
+
+const badFuncRefError = /can only pass WebAssembly exported functions to funcref/;
+
+function assertSegmentFitError(f) {
+    assertErrorMessage(f, RuntimeError, /out of bounds/);
+}
+
+var callee = i => `(func $f${i} (result i32) (i32.const ${i}))`;
+
+wasmFailValidateText(`(module (elem (i32.const 0) $f0) ${callee(0)})`, /elem segment requires a table/);
+wasmFailValidateText(`(module (table 10 funcref) (elem (i32.const 0) 0))`, /table element out of range/);
+wasmFailValidateText(`(module (table 10 funcref) (func) (elem (i32.const 0) 0 1))`, /table element out of range/);
+wasmFailValidateText(`(module (table 10 funcref) (func) (elem (f32.const 0) 0) ${callee(0)})`, /type mismatch/);
+
+assertSegmentFitError(() => wasmEvalText(`(module (table 10 funcref) (elem (i32.const 10) $f0) ${callee(0)})`));
+assertSegmentFitError(() => wasmEvalText(`(module (table 10 funcref) (elem (i32.const 8) $f0 $f0 $f0) ${callee(0)})`));
+assertSegmentFitError(() => wasmEvalText(`(module (table 0 funcref) (func) (elem (i32.const 0x10001)))`));
+
+assertSegmentFitError(() => wasmEvalText(`(module (import "globals" "a" (global i32)) (table 10 funcref) (elem (global.get 0) $f0) ${callee(0)})`, {globals:{a:10}}));
+assertSegmentFitError(() => wasmEvalText(`(module (import "globals" "a" (global i32)) (table 10 funcref) (elem (global.get 0) $f0 $f0 $f0) ${callee(0)})`, {globals:{a:8}}));
+
+assertEq(new Module(wasmTextToBinary(`(module (table 10 funcref) (elem (i32.const 1) $f0 $f0) (elem (i32.const 0) $f0) ${callee(0)})`)) instanceof Module, true);
+assertEq(new Module(wasmTextToBinary(`(module (table 10 funcref) (elem (i32.const 1) $f0 $f0) (elem (i32.const 2) $f0) ${callee(0)})`)) instanceof Module, true);
+wasmEvalText(`(module (import "globals" "a" (global i32)) (table 10 funcref) (elem (i32.const 1) $f0 $f0) (elem (global.get 0) $f0) ${callee(0)})`, {globals:{a:0}});
+wasmEvalText(`(module (import "globals" "a" (global i32)) (table 10 funcref) (elem (global.get 0) $f0 $f0) (elem (i32.const 2) $f0) ${callee(0)})`, {globals:{a:1}});
+
+// Explicit table index in a couple of ways, note this requires us to talk about the table type also.
+assertEq(new Module(wasmTextToBinary(`(module
+                                        (table 10 funcref)
+                                        (table 10 funcref)
+                                        (elem 1 (i32.const 1) func $f0 $f0)
+                                        ${callee(0)})`)) instanceof Module, true);
+assertEq(new Module(wasmTextToBinary(`(module
+                                        (table 10 funcref)
+                                        (table 10 funcref)
+                                        (elem (table 1) (i32.const 1) func $f0 $f0)
+                                        ${callee(0)})`)) instanceof Module, true);
+
+// With "funcref" rather than "func".
+assertEq(new Module(wasmTextToBinary(`(module
+                                        (table 10 funcref)
+                                        (table 10 funcref)
+                                        (elem (table 1) (i32.const 1) funcref (ref.func $f0) (ref.func $f0))
+                                        ${callee(0)})`)) instanceof Module, true);
+
+// Syntax for the offset, ditto.
+assertEq(new Module(wasmTextToBinary(`(module
+                                        (table 10 funcref)
+                                        (table 10 funcref)
+                                        (elem 1 (offset (i32.const 1)) func $f0 $f0)
+                                        ${callee(0)})`)) instanceof Module, true);
+
+var m = new Module(wasmTextToBinary(`
+    (module
+        (import "globals" "table" (table 10 funcref))
+        (import "globals" "a" (global i32))
+        (elem (global.get 0) $f0 $f0)
+        ${callee(0)})
+`));
+var tbl = new Table({initial:50, element:"anyfunc"});
+assertEq(new Instance(m, {globals:{a:20, table:tbl}}) instanceof Instance, true);
+assertSegmentFitError(() => new Instance(m, {globals:{a:50, table:tbl}}));
+
+var caller = `(type $v2i (func (result i32))) (func $call (param $i i32) (result i32) (call_indirect (type $v2i) (local.get $i))) (export "call" (func $call))`
+var callee = i => `(func $f${i} (type $v2i) (i32.const ${i}))`;
+
+var call = wasmEvalText(`(module (table 10 funcref) ${callee(0)} ${caller})`).exports.call;
+assertErrorMessage(() => call(0), RuntimeError, /indirect call to null/);
+assertErrorMessage(() => call(10), RuntimeError, /index out of bounds/);
+
+var call = wasmEvalText(`(module (table 10 funcref) (elem (i32.const 0)) ${callee(0)} ${caller})`).exports.call;
+assertErrorMessage(() => call(0), RuntimeError, /indirect call to null/);
+assertErrorMessage(() => call(10), RuntimeError, /index out of bounds/);
+
+var call = wasmEvalText(`(module (table 10 funcref) (elem (i32.const 0) $f0) ${callee(0)} ${caller})`).exports.call;
+assertEq(call(0), 0);
+assertErrorMessage(() => call(1), RuntimeError, /indirect call to null/);
+assertErrorMessage(() => call(2), RuntimeError, /indirect call to null/);
+assertErrorMessage(() => call(10), RuntimeError, /index out of bounds/);
+
+var call = wasmEvalText(`(module (table 10 funcref) (elem (i32.const 1) $f0 $f1) (elem (i32.const 4) $f0 $f2) ${callee(0)} ${callee(1)} ${callee(2)} ${caller})`).exports.call;
+assertErrorMessage(() => call(0), RuntimeError, /indirect call to null/);
+assertEq(call(1), 0);
+assertEq(call(2), 1);
+assertErrorMessage(() => call(3), RuntimeError, /indirect call to null/);
+assertEq(call(4), 0);
+assertEq(call(5), 2);
+assertErrorMessage(() => call(6), RuntimeError, /indirect call to null/);
+assertErrorMessage(() => call(10), RuntimeError, /index out of bounds/);
+
+var imports = {a:{b:()=>42}};
+var call = wasmEvalText(`(module (import "a" "b" (func $f1)) (import "a" "b" (func $f2 (result i32))) (table 10 funcref) (elem (i32.const 0) $f0 $f1 $f2) ${callee(0)} ${caller})`, imports).exports.call;
+assertEq(call(0), 0);
+assertErrorMessage(() => call(1), RuntimeError, /indirect call signature mismatch/);
+assertEq(call(2), 42);
+
+var tbl = new Table({initial:3, element:"anyfunc"});
+var call = wasmEvalText(`(module (import "a" "b" (table 3 funcref)) (export "tbl" (table 0)) (elem (i32.const 0) $f0 $f1) ${callee(0)} ${callee(1)} ${caller})`, {a:{b:tbl}}).exports.call;
+assertEq(call(0), 0);
+assertEq(call(1), 1);
+assertEq(tbl.get(0)(), 0);
+assertEq(tbl.get(1)(), 1);
+assertErrorMessage(() => call(2), RuntimeError, /indirect call to null/);
+assertEq(tbl.get(2), null);
+
+var exp = wasmEvalText(`(module (import "a" "b" (table 3 funcref)) (export "tbl" (table 0)) (elem (i32.const 2) $f2) ${callee(2)} ${caller})`, {a:{b:tbl}}).exports;
+assertEq(exp.tbl, tbl);
+assertEq(exp.call(0), 0);
+assertEq(exp.call(1), 1);
+assertEq(exp.call(2), 2);
+assertEq(call(0), 0);
+assertEq(call(1), 1);
+assertEq(call(2), 2);
+assertEq(tbl.get(0)(), 0);
+assertEq(tbl.get(1)(), 1);
+assertEq(tbl.get(2)(), 2);
+
+var exp1 = wasmEvalText(`(module (table 10 funcref) (export "tbl" (table 0)) (elem (i32.const 0) $f0 $f0) ${callee(0)} (export "f0" (func $f0)) ${caller})`).exports
+assertEq(exp1.tbl.get(0), exp1.f0);
+assertEq(exp1.tbl.get(1), exp1.f0);
+assertEq(exp1.tbl.get(2), null);
+assertEq(exp1.call(0), 0);
+assertEq(exp1.call(1), 0);
+assertErrorMessage(() => exp1.call(2), RuntimeError, /indirect call to null/);
+var exp2 = wasmEvalText(`(module (import "a" "b" (table 10 funcref)) (export "tbl" (table 0)) (elem (i32.const 1) $f1 $f1) ${callee(1)} (export "f1" (func $f1)) ${caller})`, {a:{b:exp1.tbl}}).exports
+assertEq(exp1.tbl, exp2.tbl);
+assertEq(exp2.tbl.get(0), exp1.f0);
+assertEq(exp2.tbl.get(1), exp2.f1);
+assertEq(exp2.tbl.get(2), exp2.f1);
+assertEq(exp1.call(0), 0);
+assertEq(exp1.call(1), 1);
+assertEq(exp1.call(2), 1);
+assertEq(exp2.call(0), 0);
+assertEq(exp2.call(1), 1);
+assertEq(exp2.call(2), 1);
+
+var tbl = new Table({initial:3, element:"anyfunc"});
+var e1 = wasmEvalText(`(module (func $f (result i32) (i32.const 42)) (export "f" (func $f)))`).exports;
+var e2 = wasmEvalText(`(module (func $g (result f32) (f32.const 10)) (export "g" (func $g)))`).exports;
+var e3 = wasmEvalText(`(module (func $h (result i32) (i32.const 13)) (export "h" (func $h)))`).exports;
+tbl.set(0, e1.f);
+tbl.set(1, e2.g);
+tbl.set(2, e3.h);
+var e4 = wasmEvalText(`(module (import "a" "b" (table 3 funcref)) ${caller})`, {a:{b:tbl}}).exports;
+assertEq(e4.call(0), 42);
+assertErrorMessage(() => e4.call(1), RuntimeError, /indirect call signature mismatch/);
+assertEq(e4.call(2), 13);
+
+var asmjsFun = (function() { "use asm"; function f() {} return f })();
+assertEq(isAsmJSFunction(asmjsFun), isAsmJSCompilationAvailable());
+assertErrorMessage(() => tbl.set(0, asmjsFun), TypeError, badFuncRefError);
+assertErrorMessage(() => tbl.grow(1, asmjsFun), TypeError, badFuncRefError);
+
+var m = new Module(wasmTextToBinary(`(module
+    (type $i2i (func (param i32) (result i32)))
+    (import "a" "mem" (memory 1))
+    (import "a" "tbl" (table 10 funcref))
+    (import "a" "imp" (func $imp (result i32)))
+    (func $call (param $i i32) (result i32)
+        (i32.add
+            (call $imp)
+            (i32.add
+                (i32.load (i32.const 0))
+                (if (result i32) (i32.eqz (local.get $i))
+                    (then (i32.const 0))
+                    (else
+                        (local.set $i (i32.sub (local.get $i) (i32.const 1)))
+                        (call_indirect (type $i2i) (local.get $i) (local.get $i)))))))
+    (export "call" (func $call))
+)`));
+var failTime = false;
+var tbl = new Table({initial:10, element:"anyfunc"});
+var mem1 = new Memory({initial:1});
+var e1 = new Instance(m, {a:{mem:mem1, tbl, imp() {if (failTime) throw new Error("ohai"); return 1}}}).exports;
+tbl.set(0, e1.call);
+var mem2 = new Memory({initial:1});
+var e2 = new Instance(m, {a:{mem:mem2, tbl, imp() {return 10} }}).exports;
+tbl.set(1, e2.call);
+var mem3 = new Memory({initial:1});
+var e3 = new Instance(m, {a:{mem:mem3, tbl, imp() {return 100} }}).exports;
+new Int32Array(mem1.buffer)[0] = 1000;
+new Int32Array(mem2.buffer)[0] = 10000;
+new Int32Array(mem3.buffer)[0] = 100000;
+assertEq(e3.call(2), 111111);
+failTime = true;
+assertErrorMessage(() => e3.call(2), Error, "ohai");
+
+// Call signatures are matched structurally:
+
+var call = wasmEvalText(`(module
+    (type $v2i1 (func (result i32)))
+    (type $v2i2 (func (result i32)))
+    (type $i2v (func (param i32)))
+    (table funcref (elem $a $b $c))
+    (func $a (type $v2i1) (i32.const 0))
+    (func $b (type $v2i2) (i32.const 1))
+    (func $c (type $i2v))
+    (func $call (param i32) (result i32) (call_indirect (type $v2i1) (local.get 0)))
+    (export "call" (func $call))
+)`).exports.call;
+assertEq(call(0), 0);
+assertEq(call(1), 1);
+assertErrorMessage(() => call(2), RuntimeError, /indirect call signature mismatch/);
+
+var call = wasmEvalText(`(module
+    (type $A (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (type $B (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (type $C (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (type $D (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (type $E (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (type $F (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (type $G (func (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (param i32) (result i32)))
+    (table funcref (elem $a $b $c $d $e $f $g))
+    (func $a (type $A) (local.get 7))
+    (func $b (type $B) (local.get 8))
+    (func $c (type $C) (local.get 9))
+    (func $d (type $D) (local.get 10))
+    (func $e (type $E) (local.get 11))
+    (func $f (type $F) (local.get 12))
+    (func $g (type $G) (local.get 13))
+    (func $call (param i32) (result i32)
+        (call_indirect (type $A) (i32.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i32.const 42) (local.get 0)))
+    (export "call" (func $call))
+)`).exports.call;
+assertEq(call(0), 42);
+for (var i = 1; i < 7; i++)
+    assertErrorMessage(() => call(i), RuntimeError, /indirect call signature mismatch/);
+assertErrorMessage(() => call(7), RuntimeError, /index out of bounds/);
+
+// Function identity isn't lost:
+var tbl = wasmEvalText(`(module (table (export "tbl") funcref (elem $f)) (func $f))`).exports.tbl;
+tbl.get(0).foo = 42;
+gc();
+assertEq(tbl.get(0).foo, 42);
+
+(function testCrossRealmCall() {
+    var g = newGlobal({sameCompartmentAs: this});
+
+    // The memory.size builtin asserts cx->realm matches instance->realm so
+    // we call it here.
+    var src = `
+        (module
+            (import "a" "t" (table 3 funcref))
+            (import "a" "m" (memory 1))
+            (func $f (result i32) (i32.add (i32.const 3) (memory.size)))
+            (elem (i32.const 0) $f))
+    `;
+    g.mem = new Memory({initial:4});
+    g.tbl = new Table({initial:3, element:"anyfunc"});
+    var i1 = g.evaluate("new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`" + src + "`)), {a:{t:tbl,m:mem}})");
+
+    var call = new Instance(new Module(wasmTextToBinary(`
+        (module
+            (import "a" "t" (table 3 funcref))
+            (import "a" "m" (memory 1))
+            (type $v2i (func (result i32)))
+            (func $call (param $i i32) (result i32) (i32.add (call_indirect (type $v2i) (local.get $i)) (memory.size)))
+            (export "call" (func $call)))
+    `)), {a:{t:g.tbl,m:g.mem}}).exports.call;
+
+    for (var i = 0; i < 10; i++)
+        assertEq(call(0), 11);
+})();
+
+
+// Test active segments with a table index.
+
+{
+    function makeIt(flag, tblindex) {
+        return new Uint8Array([0x00, 0x61, 0x73, 0x6d,
+                               0x01, 0x00, 0x00, 0x00,
+                               0x04,                   // Table section
+                               0x04,                   // Section size
+                               0x01,                   // One table
+                               0x70,                   // Type: FuncRef
+                               0x00,                   // Limits: Min only
+                               0x01,                   // Limits: Min
+                               0x09,                   // Elements section
+                               0x08,                   // Section size
+                               0x01,                   // One element segment
+                               flag,                   // Flag should be 2, or > 2 if invalid
+                               tblindex,               // Table index must be 0, or > 0 if invalid
+                               0x41,                   // Init expr: i32.const
+                               0x00,                   // Init expr: zero (payload)
+                               0x0b,                   // Init expr: end
+                               0x00,                   // Extern kind: Function
+                               0x00]);                 // Zero functions
+    }
+
+    // Should succeed because this is what an active segment with index looks like
+    new WebAssembly.Module(makeIt(0x02, 0x00));
+
+    // Should fail because the kind is unknown
+    assertErrorMessage(() => new WebAssembly.Module(makeIt(0x08, 0x00)),
+                       WebAssembly.CompileError,
+                       /invalid elem segment flags field/);
+
+    // Should fail because the table index is invalid
+    assertErrorMessage(() => new WebAssembly.Module(makeIt(0x02, 0x01)),
+                       WebAssembly.CompileError,
+                       /table index out of range/);
+}
diff --git a/js/src/jit-test/tests/wasm/text.js b/js/src/jit-test/tests/wasm/text.js
new file mode 100644
index 0000000000..97af720008
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/text.js
@@ -0,0 +1,123 @@
+var parsingError = /wasm text error/;
+
+assertErrorMessage(() => wasmEvalText(''), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('('), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(m'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(moduler'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (func) (export "a'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (func (local $a i32) (param $b f32)))'), SyntaxError, parsingError);
+
+assertErrorMessage(() => wasmEvalText('(module (func $a) (func) (export "a" (func $a)) (export "b" (func $b)))'), SyntaxError, /failed to find name/);
+assertErrorMessage(() => wasmEvalText('(module (import "a" "b" (func $foo)) (import "a" "b" (func $foo)))'), SyntaxError, /duplicate func identifier/);
+assertErrorMessage(() => wasmEvalText('(module (func $foo) (func $foo))'), SyntaxError, /duplicate func identifier/);
+assertErrorMessage(() => wasmEvalText('(module (func (param $a i32) (local $a i32)))'), SyntaxError, /duplicate local identifier/);
+assertErrorMessage(() => wasmEvalText('(module (func (local.get $a)))'), SyntaxError, /failed to find name/);
+assertErrorMessage(() => wasmEvalText('(module (type $a (func)) (type $a (func (param i32))))'), SyntaxError, /duplicate type identifier/);
+assertErrorMessage(() => wasmEvalText('(module (import "a" "" (func)) (func (call $abc)))'), SyntaxError, /failed to find name/);
+assertErrorMessage(() => wasmEvalText('(module (type $a (func)) (func (type $b) (i32.const 13)))'), SyntaxError, /failed to find name/);
+assertErrorMessage(() => wasmEvalText('(module (type $a (func)) (func (call_indirect (type $c) (i32.const 0) (local.get 0))))'), SyntaxError, /failed to find name/);
+assertErrorMessage(() => wasmEvalText('(module (func (br $a)))'), SyntaxError, /failed to find name/);
+assertErrorMessage(() => wasmEvalText('(module (func (block $a ) (br $a)))'), SyntaxError, /failed to find name/);
+
+assertErrorMessage(() => wasmEvalText(`(module (func (call ${0xffffffff})))`), WebAssembly.CompileError, /(callee index out of range)|(function index out of bounds)/);
+assertErrorMessage(() => wasmEvalText(`(module (export "func" ${0xffffffff}))`), SyntaxError, parsingError);
+
+wasmEvalText('(module (func (param $a i32)))');
+wasmEvalText('(module (func (param i32)))');
+wasmEvalText('(module (func (param i32 i32 f32 f64 i32)))');
+assertErrorMessage(() => wasmEvalText('(module (func (param $a)))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (func (param $a i32 i32)))'), SyntaxError, parsingError);
+
+wasmEvalText('(module (func (local $a i32)))');
+wasmEvalText('(module (func (local i32)))');
+wasmEvalText('(module (func (local i32 i32 f32 f64 i32)))');
+assertErrorMessage(() => wasmEvalText('(module (func (local $a)))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (func (local $a i32 i32)))'), SyntaxError, parsingError);
+
+// Table
+assertErrorMessage(() => wasmEvalText('(module (table (local $a)))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (table $t))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (table $t 1))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (table $t 1 10))'), SyntaxError, parsingError);
+wasmEvalText('(module (table $t 1 10 funcref))');
+wasmEvalText('(module (table $t 1 funcref))');
+wasmEvalText('(module (table 0 funcref))');
+
+assertErrorMessage(() => wasmEvalText('(module (table $t funcref))'), SyntaxError, parsingError);
+wasmEvalText('(module (table $t funcref (elem)))');
+wasmEvalText('(module (func) (table $t funcref (elem 0 0 0)))');
+
+const { Table } = WebAssembly;
+const table = new Table({initial:1, element:"anyfunc"});
+assertErrorMessage(() => wasmEvalText('(module (table $t (import) 1 funcref))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (table $t (import "mod" "field") 1 funcref (elem 1 2 3)))'), SyntaxError, parsingError);
+wasmEvalText('(module (table $t (import "mod" "field") 1 funcref))', {mod: {field: table}});
+
+assertErrorMessage(() => wasmEvalText('(module (table $t (export "mod") 1))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (table $t (export "mod") funcref))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (table $t (export "mod") funcref 1 2 3))'), SyntaxError, parsingError);
+assertEq(wasmEvalText('(module (table $t (export "tbl") funcref (elem)))').exports.tbl instanceof Table, true);
+assertEq(wasmEvalText('(module (func) (table $t (export "tbl") funcref (elem 0 0 0)))').exports.tbl instanceof Table, true);
+
+// Functions.
+assertErrorMessage(() => wasmEvalText('(module (func $t import))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (func $t (import)))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (func $t (import "mod" "func" (local i32))))'), SyntaxError, parsingError);
+
+const func = i => 42 + i;
+wasmEvalText('(module (func $t (import "mod" "func")))', { mod: {func} });
+wasmEvalText('(module (func $t (import "mod" "func") (param i32)))', { mod: {func} });
+wasmEvalText('(module (func $t (import "mod" "func") (result i32)))', { mod: {func} });
+wasmEvalText('(module (func $t (import "mod" "func") (param i32) (result i32)))', { mod: {func} });
+wasmEvalText('(module (func $t (import "mod" "func") (param i32)))', { mod: {func} });
+
+assertErrorMessage(() => wasmEvalText('(module (func $t (import "mod" "func") (type)))', { mod: {func} }), SyntaxError, parsingError);
+wasmEvalText('(module (type $t (func)) (func $t (import "mod" "func") (type $t)))', { mod: {func} });
+
+assertErrorMessage(() => wasmEvalText('(module (func $t (export))))'), SyntaxError, parsingError);
+wasmEvalText('(module (func (export "f")))');
+wasmEvalText('(module (func $f (export "f")))');
+wasmEvalText('(module (func $f (export "f") (param i32) (result i32) (i32.add (local.get 0) (i32.const 42))))');
+
+assertErrorMessage(() => wasmEvalText(`
+    (module
+        (type $tf (func (param i32) (result i32)))
+        (func (import "mod" "a") (type $tf))
+        (func (export "f1"))
+        (func (import "mod" "b") (type $tf))
+        (func (export "f2"))
+    )
+`), SyntaxError, /import after function/);
+
+// Globals.
+assertErrorMessage(() => wasmEvalText('(module (global $t (export)))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (global $t (export "g")))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (global $t (export "g") i32))'), WebAssembly.CompileError, /popping value/);
+wasmEvalText('(module (global $t (export "g") i32 (i32.const 42)))');
+
+assertErrorMessage(() => wasmEvalText('(module (global $t (import) i32))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (global $t (import "mod" "field")))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (global $t (import "mod" "field")) i32 (i32.const 42))'), SyntaxError, parsingError);
+wasmEvalText('(module (global $t (import "mod" "field") i32))', { mod: {field: 42} });
+
+assertErrorMessage(() => wasmEvalText(`
+    (module
+        (global (import "mod" "a") i32)
+        (global (export "f1") i32 (i32.const 42))
+        (global (import "mod" "b") i32)
+    )
+`), SyntaxError, /import after global/);
+
+// Memory.
+assertErrorMessage(() => wasmEvalText('(module (memory (export)))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (memory (export "g")))'), SyntaxError, parsingError);
+wasmEvalText('(module (memory $t (export "g") 0))');
+
+const mem = new WebAssembly.Memory({ initial: 1 });
+assertErrorMessage(() => wasmEvalText('(module (memory $t (import) 1))'), SyntaxError, parsingError);
+assertErrorMessage(() => wasmEvalText('(module (memory $t (import "mod" "field")))'), SyntaxError, parsingError);
+wasmEvalText('(module (memory $t (import "mod" "field") 1))', { mod: {field: mem} });
+
+// Note: the s-expression text format is temporary, this file is mostly just to
+// hold basic error smoke tests.
diff --git a/js/src/jit-test/tests/wasm/timeout/1.js b/js/src/jit-test/tests/wasm/timeout/1.js
new file mode 100644
index 0000000000..f731e7910f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/1.js
@@ -0,0 +1,15 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmIsSupported()
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+var code = wasmTextToBinary(`(module
+    (func (export "iloop")
+        (loop $top br $top)
+    )
+)`);
+
+var i = new WebAssembly.Instance(new WebAssembly.Module(code));
+timeout(1);
+i.exports.iloop();
+assertEq(true, false);
diff --git a/js/src/jit-test/tests/wasm/timeout/2.js b/js/src/jit-test/tests/wasm/timeout/2.js
new file mode 100644
index 0000000000..25267f226c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/2.js
@@ -0,0 +1,30 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmIsSupported()
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+var tbl = new WebAssembly.Table({initial:1, element:"anyfunc"});
+
+new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`(module
+    (import "imports" "tbl" (table 1 funcref))
+    (func $iloop
+        loop $top
+            br $top
+        end
+    )
+    (elem (i32.const 0) $iloop)
+)`)), {imports:{tbl}});
+
+var outer = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`(module
+    (import "imports" "tbl" (table 1 funcref))
+    (type $v2v (func))
+    (func (export "run")
+        i32.const 0
+        call_indirect (type $v2v)
+    )
+)`)), {imports:{tbl}});
+
+setJitCompilerOption('simulator.always-interrupt', 1);
+timeout(1, () => { tbl.set(0, null); gc() });
+outer.exports.run();
+assertEq(true, false);
diff --git a/js/src/jit-test/tests/wasm/timeout/debug-interrupt-1.js b/js/src/jit-test/tests/wasm/timeout/debug-interrupt-1.js
new file mode 100644
index 0000000000..940bde07a1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/debug-interrupt-1.js
@@ -0,0 +1,23 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmDebuggingEnabled()
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+// Note: this test triggers an interrupt and then iloops in Wasm code. If the
+// interrupt fires before the Wasm code is compiled, the test relies on the
+// JS interrupt check in onEnterFrame to catch it. Warp/Ion code however can
+// elide the combined interrupt/overrecursion check in simple leaf functions.
+// Long story short, set the Warp threshold to a non-zero value to prevent
+// intermittent timeouts with --ion-eager.
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+var g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval("Debugger(parent).onEnterFrame = function() {};");
+timeout(0.01);
+var code = wasmTextToBinary(`(module
+    (func (export "f1")
+        (loop $top br $top)
+    )
+)`);
+new WebAssembly.Instance(new WebAssembly.Module(code)).exports.f1();
diff --git a/js/src/jit-test/tests/wasm/timeout/debug-interrupt-2.js b/js/src/jit-test/tests/wasm/timeout/debug-interrupt-2.js
new file mode 100644
index 0000000000..7c0d16aeae
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/debug-interrupt-2.js
@@ -0,0 +1,28 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmDebuggingEnabled()
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+// Note: this test triggers an interrupt and then iloops in Wasm code. If the
+// interrupt fires before the Wasm code is compiled, the test relies on the
+// JS interrupt check in onEnterFrame to catch it. Warp/Ion code however can
+// elide the combined interrupt/overrecursion check in simple leaf functions.
+// Long story short, set the Warp threshold to a non-zero value to prevent
+// intermittent timeouts with --ion-eager.
+setJitCompilerOption("ion.warmup.trigger", 30);
+
+var g = newGlobal({newCompartment: true});
+g.parent = this;
+g.eval("Debugger(parent).onEnterFrame = function() {};");
+timeout(0.01);
+var code = wasmTextToBinary(`(module
+    (func $f2
+        loop $top
+            br $top
+        end
+    )
+    (func (export "f1")
+        call $f2
+    )
+)`);
+new WebAssembly.Instance(new WebAssembly.Module(code)).exports.f1();
diff --git a/js/src/jit-test/tests/wasm/timeout/debug-noprofiling.js b/js/src/jit-test/tests/wasm/timeout/debug-noprofiling.js
new file mode 100644
index 0000000000..5b1cdd4192
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/debug-noprofiling.js
@@ -0,0 +1,31 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmDebuggingEnabled()
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+newGlobal({newCompartment: true}).Debugger().addDebuggee(this);
+
+var t = new WebAssembly.Table({
+    initial: 1,
+    element: "anyfunc"
+});
+
+new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (import "imports" "t" (table 1 funcref))
+    (func $iloop loop $top br $top end)
+    (elem (i32.const 0) $iloop))
+`)), { imports: { t } });
+
+outer = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary(`
+(module
+    (import "imports" "t" (table 1 funcref))
+    (type $v2v (func))
+    (func (export "run")
+        i32.const 0
+        call_indirect (type $v2v))
+    )`)), { imports: { t } });
+
+setJitCompilerOption('simulator.always-interrupt', 1);
+timeout(1);
+outer.exports.run();
diff --git a/js/src/jit-test/tests/wasm/timeout/directives.txt b/js/src/jit-test/tests/wasm/timeout/directives.txt
new file mode 100644
index 0000000000..08048b372f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/directives.txt
@@ -0,0 +1,2 @@
+|jit-test| test-also=--wasm-compiler=optimizing; test-also=--wasm-compiler=baseline; test-also=--test-wasm-await-tier2; test-also=--disable-wasm-huge-memory; skip-variant-if: --disable-wasm-huge-memory, !wasmHugeMemorySupported();
+
diff --git a/js/src/jit-test/tests/wasm/timeout/interrupt-multi-instance-activation.js b/js/src/jit-test/tests/wasm/timeout/interrupt-multi-instance-activation.js
new file mode 100644
index 0000000000..05ac7ff51a
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/interrupt-multi-instance-activation.js
@@ -0,0 +1,28 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmIsSupported()
+
+const {Module, Instance} = WebAssembly;
+
+const {innerWasm} = new Instance(new Module(wasmTextToBinary(`(module
+    (func (export "innerWasm") (result i32)
+        (local i32)
+        (loop $top
+            (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+            (br_if $top (i32.lt_u (local.get 0) (i32.const 100000)))
+        )
+        (local.get 0)
+    )
+)`))).exports;
+
+function middleJS() {
+    innerWasm();
+}
+
+const {outerWasm} = new Instance(new Module(wasmTextToBinary(`(module
+    (func $middleJS (import "" "middleJS"))
+    (func (export "outerWasm") (call $middleJS))
+)`)), {'':{middleJS}}).exports;
+
+timeout(1);
+while (true) {
+    outerWasm();
+}
diff --git a/js/src/jit-test/tests/wasm/timeout/interrupt-several-instances.js b/js/src/jit-test/tests/wasm/timeout/interrupt-several-instances.js
new file mode 100644
index 0000000000..58dc642d16
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/interrupt-several-instances.js
@@ -0,0 +1,21 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmIsSupported()
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+load(libdir + "asm.js");
+
+var code = `
+    var out = ffi.out;
+    function f() {
+        out();
+    }
+    return f;
+`;
+
+var ffi = {};
+ffi.out = new WebAssembly.Instance(new WebAssembly.Module(wasmTextToBinary('(module (func (export "f") (loop $top (br $top))))'))).exports.f;
+
+timeout(1);
+asmLink(asmCompile('glob', 'ffi', USE_ASM + code), this, ffi)();
+assertEq(true, false);
diff --git a/js/src/jit-test/tests/wasm/timeout/stack-overflow.js b/js/src/jit-test/tests/wasm/timeout/stack-overflow.js
new file mode 100644
index 0000000000..cf79b7d84c
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/stack-overflow.js
@@ -0,0 +1,97 @@
+// |jit-test| exitstatus: 3; skip-if: !wasmIsSupported()
+
+let { exports } = new WebAssembly.Instance(
+    new WebAssembly.Module(wasmTextToBinary(`
+    (module
+        (func (export "f") (param i32) (param i32) (param i32) (param i32) (result i32)
+            get_local 0
+            i32.popcnt
+            get_local 1
+            i32.popcnt
+            i32.add
+
+            get_local 2
+            i32.popcnt
+            get_local 3
+            i32.popcnt
+            i32.add
+
+            get_local 0
+            get_local 1
+            i32.sub
+
+            get_local 2
+            get_local 3
+            i32.sub
+
+            get_local 0
+            get_local 1
+            i32.mul
+
+            get_local 2
+            get_local 3
+            i32.mul
+
+            get_local 0
+            get_local 2
+            i32.sub
+
+            get_local 1
+            get_local 3
+            i32.sub
+
+            get_local 0
+            get_local 1
+            i32.add
+
+            get_local 2
+            get_local 3
+            i32.add
+
+            get_local 0
+            get_local 2
+            i32.add
+
+            get_local 1
+            get_local 3
+            i32.add
+
+            get_local 0
+            i32.ctz
+            get_local 1
+            i32.ctz
+            i32.add
+
+            get_local 2
+            i32.ctz
+            get_local 3
+            i32.ctz
+
+            get_local 0
+            get_local 1
+            get_local 2
+            get_local 3
+            call 0
+
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+            i32.add
+        )
+    )
+    `))
+);
+
+timeout(1, function() {});
+exports.f()
diff --git a/js/src/jit-test/tests/wasm/timeout/while-profiling.js b/js/src/jit-test/tests/wasm/timeout/while-profiling.js
new file mode 100644
index 0000000000..1c008f0d94
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/timeout/while-profiling.js
@@ -0,0 +1,19 @@
+// |jit-test| exitstatus: 6; skip-if: !wasmIsSupported() || !getBuildConfiguration()['arm-simulator']
+
+// Single-step profiling currently only works in the ARM simulator
+
+// Don't include wasm.js in timeout tests: when wasm isn't supported, it will
+// quit(0) which will cause the test to fail.
+
+var code = wasmTextToBinary(`(module
+    (func (export "iloop")
+        (loop $top br $top)
+    )
+)`);
+
+enableGeckoProfiling();
+enableSingleStepProfiling();
+var i = new WebAssembly.Instance(new WebAssembly.Module(code));
+timeout(.1);
+i.exports.iloop();
+assertEq(true, false);
diff --git a/js/src/jit-test/tests/wasm/trap-exit-stack-alignment.js b/js/src/jit-test/tests/wasm/trap-exit-stack-alignment.js
new file mode 100644
index 0000000000..2d953e04a9
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/trap-exit-stack-alignment.js
@@ -0,0 +1,123 @@
+// Function with high register pressure to force spills without function calls
+// even on ARM64, and with a trap exit.
+let func = wasmEvalText(`(module
+    (func
+        (param i32)
+        (result i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local i32)
+        (local.set 2 (i32.add (local.get 0 i32.const 4)))
+        (local.set 3 (i32.add (local.get 0 i32.const 5)))
+        (local.set 4 (i32.add (local.get 0 i32.const 6)))
+        (local.set 5 (i32.add (local.get 0 i32.const 7)))
+        (local.set 6 (i32.add (local.get 0 i32.const 8)))
+        (local.set 7 (i32.add (local.get 0 i32.const 9)))
+        (local.set 8 (i32.add (local.get 0 i32.const 10)))
+        (local.set 9 (i32.add (local.get 0 i32.const 11)))
+        (local.set 10 (i32.add (local.get 0 i32.const 12)))
+        (local.set 11 (i32.add (local.get 0 i32.const 13)))
+        (local.set 12 (i32.add (local.get 0 i32.const 14)))
+        (local.set 13 (i32.add (local.get 0 i32.const 15)))
+        (local.set 14 (i32.add (local.get 0 i32.const 16)))
+        (local.set 15 (i32.add (local.get 0 i32.const 17)))
+        (local.set 16 (i32.add (local.get 0 i32.const 18)))
+        (local.set 17 (i32.add (local.get 0 i32.const 19)))
+        (local.set 18 (i32.add (local.get 0 i32.const 20)))
+        (local.set 19 (i32.add (local.get 0 i32.const 21)))
+        (local.set 20 (i32.add (local.get 0 i32.const 22)))
+        (local.set 21 (i32.add (local.get 0 i32.const 23)))
+        (local.set 22 (i32.add (local.get 0 i32.const 24)))
+        (local.set 23 (i32.add (local.get 0 i32.const 25)))
+        (local.set 24 (i32.add (local.get 0 i32.const 26)))
+        (local.set 25 (i32.add (local.get 0 i32.const 27)))
+        (local.set 26 (i32.add (local.get 0 i32.const 28)))
+        (local.set 7 (i32.div_s (local.get 0) (local.get 0)))
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        local.get 4
+        local.get 5
+        local.get 6
+        local.get 7
+        local.get 8
+        local.get 9
+        local.get 10
+        local.get 11
+        local.get 12
+        local.get 13
+        local.get 14
+        local.get 15
+        local.get 16
+        local.get 17
+        local.get 18
+        local.get 19
+        local.get 20
+        local.get 21
+        local.get 22
+        local.get 23
+        local.get 24
+        local.get 25
+        local.get 26
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+        i32.add
+    )
+    (export "" (func 0))
+)`).exports[""];
+assertEq(func(1), 417);
+assertEq(func(2), 442);
+let ex;
+try {
+  func(0);
+} catch (e) {
+  ex = e;
+}
+assertEq(ex instanceof WebAssembly.RuntimeError, true);
diff --git a/js/src/jit-test/tests/wasm/udiv.js b/js/src/jit-test/tests/wasm/udiv.js
new file mode 100644
index 0000000000..446f23c202
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/udiv.js
@@ -0,0 +1,68 @@
+function test_i32_udiv_n2() {
+    return wasmEvalText(
+      `(module
+         (type (;0;) (func (param i32) (result i32)))
+         (func (;0;) (type 0) (param i32) (result i32)
+           local.get 0
+           i32.const -2
+           i32.div_u)
+         (export "main" (func 0)))`
+    ).exports["main"];
+}
+function test_i32_udiv_n1() {
+    return wasmEvalText(
+      `(module
+         (type (;0;) (func (param i32) (result i32)))
+         (func (;0;) (type 0) (param i32) (result i32)
+           local.get 0
+           i32.const -1
+           i32.div_u)
+         (export "main" (func 0)))`
+    ).exports["main"];
+}
+function test_i32_udiv_p2() {
+    return wasmEvalText(
+      `(module
+         (type (;0;) (func (param i32) (result i32)))
+         (func (;0;) (type 0) (param i32) (result i32)
+           local.get 0
+           i32.const 2
+           i32.div_u)
+         (export "main" (func 0)))`
+    ).exports["main"];
+}
+function test_i32_udiv_p1() {
+    return wasmEvalText(
+      `(module
+         (type (;0;) (func (param i32) (result i32)))
+         (func (;0;) (type 0) (param i32) (result i32)
+           local.get 0
+           i32.const 1
+           i32.div_u)
+         (export "main" (func 0)))`
+    ).exports["main"];
+}
+
+let udiv_p1 = test_i32_udiv_p1();
+assertEq(udiv_p1(1), 1);
+assertEq(udiv_p1(2), 2);
+assertEq(udiv_p1(0x7fffffff), 0x7fffffff);
+assertEq(udiv_p1(-1), -1); // results are converted to i32.
+
+let udiv_p2 = test_i32_udiv_p2();
+assertEq(udiv_p2(1), 0);
+assertEq(udiv_p2(2), 1);
+assertEq(udiv_p2(0x7fffffff), 0x7fffffff >> 1);
+assertEq(udiv_p2(-1), 0x7fffffff); // -1 is converted to u32.
+
+let udiv_n1 = test_i32_udiv_n1();
+assertEq(udiv_n1(1), 0);
+assertEq(udiv_n1(2), 0);
+assertEq(udiv_n1(0x7fffffff), 0);
+assertEq(udiv_n1(-1), 1);
+
+let udiv_n2 = test_i32_udiv_n2();
+assertEq(udiv_n2(1), 0);
+assertEq(udiv_n2(2), 0);
+assertEq(udiv_n2(0x7fffffff), 0);
+assertEq(udiv_n2(-1), 1);
diff --git a/js/src/jit-test/tests/wasm/unsupported/README.md b/js/src/jit-test/tests/wasm/unsupported/README.md
new file mode 100644
index 0000000000..9687e7a9b6
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/unsupported/README.md
@@ -0,0 +1 @@
+DO NOT ADD A directives.txt FILE IN THIS DIRECTORY.  THE TEST CASE MUST RUN WITH MINIMAL PRELIMINARIES.
diff --git a/js/src/jit-test/tests/wasm/unsupported/requires-armv7.js b/js/src/jit-test/tests/wasm/unsupported/requires-armv7.js
new file mode 100644
index 0000000000..88acfe502f
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/unsupported/requires-armv7.js
@@ -0,0 +1,5 @@
+// |jit-test| skip-if: !getBuildConfiguration().arm; --arm-hwcap=vfp
+
+// Wasm should be unavailable in this configuration: floating point without
+// armv7, and armv7 is required for atomics and unaligned accesses.
+assertEq(typeof WebAssembly, "undefined");
diff --git a/js/src/jit-test/tests/wasm/unsupported/requires-floatingpoint.js b/js/src/jit-test/tests/wasm/unsupported/requires-floatingpoint.js
new file mode 100644
index 0000000000..40744ab130
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/unsupported/requires-floatingpoint.js
@@ -0,0 +1,4 @@
+// |jit-test| skip-if: !getBuildConfiguration().arm; --arm-hwcap=armv7
+
+// Wasm should be unavailable in this configuration: armv7 without floating point.
+assertEq(typeof WebAssembly, "undefined");
diff --git a/js/src/jit-test/tests/wasm/utf8.js b/js/src/jit-test/tests/wasm/utf8.js
new file mode 100644
index 0000000000..fdda7ab0ca
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/utf8.js
@@ -0,0 +1,36 @@
+/*
+(module
+ (func (param i32) (result i32)
+       (i32.add (local.get 0) (local.get 0)))
+ (export "hello" (func 0)))
+*/
+
+var txt =
+`00 61 73 6d 01 00 00 00 01 06 01 60 01 7f 01 7f
+ 03 02 01 00 07 09 01 05 68 65 6c 6c 6f 00 00 0a
+ 09 01 07 00 20 00 20 00 6a 0b`
+
+var bin = new Uint8Array(txt.split(" ").map((x) => parseInt(x, 16)));
+var mod = new WebAssembly.Module(bin);
+var ins = new WebAssembly.Instance(mod);
+
+assertEq(ins.exports.hello(37), 2*37);
+
+assertEq(bin[25], 0x65);	// the 'e' in 'hello'
+bin[25] = 0x85;			// bad UTF-8
+
+assertEq(WebAssembly.validate(bin), false);
+
+assertThrowsInstanceOf(() => new WebAssembly.Module(bin), WebAssembly.CompileError);
+
+assertThrowsInstanceOf(() => wasmEvalText(`(module (import "\u2603" "" (func))) `, {}), TypeError);
+
+{
+    let i1 = wasmEvalText(` (module (func (export "\u2603")))`);
+    assertThrowsInstanceOf(() => wasmEvalText(`(module (import "" "\u2603" (func (result i32))))`,
+                                              { "": { "\u2603": i1.exports['\u2603'] } }),
+                           WebAssembly.LinkError);
+    assertThrowsInstanceOf(() => wasmEvalText(`(module (import "\u2603" "" (func (result i32))))`,
+                                              { "\u2603": { "": i1.exports['\u2603'] } }),
+                           WebAssembly.LinkError);
+}
diff --git a/js/src/jit-test/tests/wasm/validate.js b/js/src/jit-test/tests/wasm/validate.js
new file mode 100644
index 0000000000..64babd86ee
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/validate.js
@@ -0,0 +1,23 @@
+const { validate } = WebAssembly;
+
+assertErrorMessage(() => validate(), Error, /At least 1 argument required/);
+
+const argError = /first argument must be an ArrayBuffer or typed array object/;
+assertErrorMessage(() => validate(null), Error, argError);
+assertErrorMessage(() => validate(true), Error, argError);
+assertErrorMessage(() => validate(42), Error, argError);
+assertErrorMessage(() => validate(NaN), Error, argError);
+assertErrorMessage(() => validate('yo'), Error, argError);
+assertErrorMessage(() => validate([]), Error, argError);
+assertErrorMessage(() => validate({}), Error, argError);
+assertErrorMessage(() => validate(Symbol.iterator), Error, argError);
+assertErrorMessage(() => validate({ valueOf: () => new ArrayBuffer(65536) }), Error, argError);
+
+assertEq(validate(wasmTextToBinary(`(module)`)), true);
+
+assertEq(validate(wasmTextToBinary(`(module (export "run" (func 0)))`)), false);
+assertEq(validate(wasmTextToBinary(`(module (func) (export "run" (func 0)))`)), true);
+
+// Feature-testing proof-of-concept.
+assertEq(validate(wasmTextToBinary(`(module (memory 1) (func (result i32) (memory.size)))`)), true);
+assertEq(validate(wasmTextToBinary(`(module (memory 1) (func (result i32) (memory.grow (i32.const 42))))`)), true);
diff --git a/js/src/jit-test/tests/wasm/wasm-abi.js b/js/src/jit-test/tests/wasm/wasm-abi.js
new file mode 100644
index 0000000000..0301bfffac
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/wasm-abi.js
@@ -0,0 +1,39 @@
+for (let numLocals of [3, 4, 5, 6, 17, 18, 19]) {
+    for (let numParams of [1, 2, 3, 4, 5, 6, 7, 8]) {
+        let locals = `       (local `;
+        let setLocals = ``;
+        let getLocals = ``;
+        let adds = ``;
+        let sum = 0;
+        for (let i = 0; i < numLocals; i++) {
+            sum += i + 1;
+            locals += `i32 `;
+            setLocals += `       (local.set ${i + 1} (i32.add (local.get 0) (i32.const ${i + 1})))\n`;
+            getLocals += `       local.get ${i + 1}\n`;
+            if (i > 0)
+              adds += `       i32.add\n`;
+        }
+        locals += `)\n`;
+
+        var callee = `    (func $f (param `;
+        var caller = `       (call $f `;
+        for (let i = 0; i < numParams; i++) {
+            callee += `f32 `;
+            caller += `(f32.const ${i}) `;
+        }
+        callee += `))\n`;
+        caller += `)\n`;
+
+        var code = `(module \n` +
+                   callee +
+                   `    (func (export "run") (param i32) (result i32)\n` +
+                   locals +
+                   setLocals +
+                   caller +
+                   getLocals +
+                   adds +
+                   `    )\n` +
+                   `)`;
+        wasmFullPass(code, numLocals * 100 + sum, undefined, 100);
+    }
+}
diff --git a/js/src/jit-test/tests/wasm/widening-i32-after-call.js b/js/src/jit-test/tests/wasm/widening-i32-after-call.js
new file mode 100644
index 0000000000..71dede01b1
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/widening-i32-after-call.js
@@ -0,0 +1,51 @@
+// |jit-test| skip-if: !hasDisassembler() || !(wasmCompileMode() == "baseline" || wasmCompileMode() == "ion") || !(getBuildConfiguration().x64 && !getBuildConfiguration()["arm64-simulator"] && !getBuildConfiguration()["mips64-simulator"])
+
+// We widen i32 results after calls on 64-bit platforms for two reasons:
+//
+// - it's a cheap mitigation for certain spectre problems, and
+// - it makes the high bits of the 64-bit register conform to platform
+//   conventions, which they might not if the call was to C++ code
+//   especially.
+//
+// This is a whitebox test that explicit widening instructions are inserted
+// after calls on x64.  The widening is platform-specific; on x64, the upper
+// bits are zeroed.
+
+// What we can't test here is the direct-call-from-JIT path, as the generated
+// code is not available to wasmDis.
+
+var ins = wasmEvalText(`
+(module
+  (import "" "wasm2import" (func $g (result i32)))
+  (memory 1)
+  (type $ty (func (result i32)))
+  (table $t 1 1 funcref)
+  (func $f (result i32)
+    (i32.const 37))
+  (func (export "wasm2wasm") (result i32)
+    (call $f))
+  (func (export "wasm2import") (result i32)
+    (call $g))
+  (func (export "wasmIndirect") (result i32)
+    (call_indirect $t (type $ty) (i32.const 0)))
+  (func (export "instanceCall") (result i32)
+    (memory.size))
+)`, {'':{'wasm2import': function() {}}});
+
+switch (wasmCompileMode()) {
+case "ion":
+    assertEq(wasmDis(ins.exports.wasm2wasm, {tier:'stable', asString:true}).match(/call.*\n.*mov %eax, %eax/).length, 1);
+    assertEq(wasmDis(ins.exports.wasm2import, {tier:'stable', asString:true}).match(/call.*\n(?:.*movq.*\n)*.*mov %eax, %eax/).length, 1);
+    assertEq(wasmDis(ins.exports.wasmIndirect, {tier:'stable', asString:true}).match(/call.*\n(?:.*movq.*\n)*.*mov %eax, %eax/).length, 1);
+    assertEq(wasmDis(ins.exports.instanceCall, {tier:'stable', asString:true}).match(/call.*\n(?:.*movq.*\n)*.*mov %eax, %eax/).length, 1);
+    break;
+case "baseline":
+    assertEq(wasmDis(ins.exports.wasm2wasm, {tier:'stable', asString:true}).match(/call.*\n.*add.*%rsp\n.*mov %eax, %eax/).length, 1);
+    assertEq(wasmDis(ins.exports.wasm2import, {tier:'stable', asString:true}).match(/call.*\n.*add.*%rsp\n(?:.*movq.*\n)*.*mov %eax, %eax/).length, 1);
+    assertEq(wasmDis(ins.exports.wasmIndirect, {tier:'stable', asString:true}).match(/call.*\n.*add.*%rsp\n(?:.*movq.*\n)*.*mov %eax, %eax/).length, 1);
+    assertEq(wasmDis(ins.exports.instanceCall, {tier:'stable', asString:true}).match(/call.*\n.*add.*%rsp\n(?:.*movq.*\n)*.*mov %eax, %eax/).length, 1);
+    break;
+default:
+    throw "Unexpected compile mode";
+}
+
diff --git a/js/src/jit-test/tests/wasm/worker-kill.js b/js/src/jit-test/tests/wasm/worker-kill.js
new file mode 100644
index 0000000000..36b5ab9562
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/worker-kill.js
@@ -0,0 +1,10 @@
+// |jit-test| skip-if: helperThreadCount() === 0
+
+evalInWorker(`
+    var code = "(module ";
+    for (var i = 0; i < 100; i++)
+        code += "(func (param i32) (result i32) (i32.add (i32.const 1) (local.get 0))) ";
+    code += ")";
+    var buf = wasmTextToBinary(code);
+    WebAssembly.compile(buf);
+`);